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
fix(oceanbase-oracle): handle manual transactions on grid save/switch
efeirea19a4f595d41
diff --git a/apps/desktop/src/components/grid/DataGrid.vue b/apps/desktop/src/components/grid/DataGrid.vueindex 2986c1515f..be120b9379 100644--- a/apps/desktop/src/components/grid/DataGrid.vue+++ b/apps/desktop/src/components/grid/DataGrid.vue@@ -534,6 +534,7 @@ interface DataGridProps {exportFileBaseName?: string;customSaveHandler?: import("@/composables/useDataGridEditor").CustomSaveHandler;manualTransactionSessionId?: string;+ ensureManualTransactionSession?: () => Promise<string>;onManualTransactionMutation?: () => void;mongoUpdateTarget?: MongoCopyUpdateTarget;/** Enables MongoDB collection-grid presentation for BSON null values. */@@ -3706,6 +3707,7 @@ const editor = useDataGridEditor({onExecuteSql: computed(() => props.onExecuteSql),customSaveHandler: computed(() => props.customSaveHandler),manualTransactionSessionId: computed(() => props.manualTransactionSessionId),+ ensureManualTransactionSession: computed(() => props.ensureManualTransactionSession),onManualTransactionMutation: () => props.onManualTransactionMutation?.(),sql: computed(() => props.sql),searchText,diff --git a/apps/desktop/src/components/layout/ContentArea.vue b/apps/desktop/src/components/layout/ContentArea.vueindex 2b8a00cc66..917e8bd131 100644--- a/apps/desktop/src/components/layout/ContentArea.vue+++ b/apps/desktop/src/components/layout/ContentArea.vue@@ -2091,6 +2091,7 @@ defineExpose({:mongo-update-target="mongoQueryResultSaveHandler && activeTab.result.mongo_copy_documents?.length === activeTab.result.rows.length ? activeTab.mongoEditTarget : undefined":query-editability-reason="activeTab.queryEditabilityReason":manual-transaction-session-id="activeTab.txnSessionId"+ :ensure-manual-transaction-session="activeTab.autoCommit === false ? () => queryStore.ensureManualTransactionSession(activeTab.id, activeResultDatabase, activeResultSchema) : undefined":on-manual-transaction-mutation="() => queryStore.markManualTransactionDirty(activeTab.id)":allow-insert-rows="activeTab.queryAnalysis?.allowInsert ?? activeTab.queryAnalysis?.allowInsertDelete !== false":allow-delete-rows="activeTab.queryAnalysis?.allowDelete ?? activeTab.queryAnalysis?.allowInsertDelete !== false"diff --git a/apps/desktop/src/composables/__tests__/useDataGridEditor.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridEditor.spec.tsindex 8ec15611a3..0106bad0e7 100644--- a/apps/desktop/src/composables/__tests__/useDataGridEditor.spec.ts+++ b/apps/desktop/src/composables/__tests__/useDataGridEditor.spec.ts@@ -949,6 +949,7 @@ describe("useDataGridEditor saveChanges reload", () => {prepareFullReload?: () => void;customSaveHandler?: { save: ReturnType<typeof vi.fn> };manualTransactionSessionId?: string;+ ensureManualTransactionSession?: () => Promise<string>;refreshSavedRows?: ReturnType<typeof vi.fn>;onManualTransactionMutation?: ReturnType<typeof vi.fn>;connectionId?: string;@@ -958,6 +959,7 @@ describe("useDataGridEditor saveChanges reload", () => {) {const emit = vi.fn();const currentPage = options.currentPage ?? ref(1);+ const ensureManualTransactionSession = ref(options.ensureManualTransactionSession);const result = ref<{ columns: string[]; rows: CellValue[][] }>({columns: ["id", "status"],rows: [@@ -985,6 +987,7 @@ describe("useDataGridEditor saveChanges reload", () => {onExecuteSql: computed(() => options.onExecuteSql),customSaveHandler: computed(() => options.customSaveHandler),manualTransactionSessionId: computed(() => options.manualTransactionSessionId),+ ensureManualTransactionSession: computed(() => ensureManualTransactionSession.value),onManualTransactionMutation: options.onManualTransactionMutation,sql: computed(() => undefined),searchText: ref(""),@@ -1001,7 +1004,7 @@ describe("useDataGridEditor saveChanges reload", () => {refreshSavedRows: options.refreshSavedRows,emit,});- return { editor, emit, currentPage };+ return { editor, emit, currentPage, ensureManualTransactionSession };}// https://github.com/t8y2/dbx/issues/8321: without a primary key the row is@@ -1148,6 +1151,53 @@ describe("useDataGridEditor saveChanges reload", () => {expect(emit).toHaveBeenCalledWith("reload", undefined, "", undefined, undefined, 100, 0);});+ it("starts a manual transaction before saving an existing result grid", async () => {+ const statement = "UPDATE orders_test SET status='shipped' WHERE id=1";+ const ensureManualTransactionSession = vi.fn().mockResolvedValue("txn-grid-1");+ mocks.prepareDataGridSave.mockResolvedValue({ statements: [statement], rollbackStatements: [] });+ mocks.executeInManualTransaction.mockResolvedValue([{ affected_rows: 1 }]);++ const { editor, ensureManualTransactionSession: transactionMode } = createSaveTestEditor();+ transactionMode.value = ensureManualTransactionSession;+ editor.dirtyRows.value.set(0, new Map([[1, "shipped"]]));+ await editor.saveChanges();++ expect(ensureManualTransactionSession).toHaveBeenCalledOnce();+ expect(mocks.executeInManualTransaction).toHaveBeenCalledWith("txn-grid-1", statement, "app", undefined);+ expect(mocks.executeBatch).not.toHaveBeenCalled();+ });++ it("checks a keyless edit on the newly opened manual transaction session", async () => {+ mocks.prepareDataGridSave.mockResolvedValue({+ statements: ["UPDATE orders_test SET status='shipped' WHERE status = 'pending'"],+ rollbackStatements: [],+ keylessGuards: [keylessGuard],+ });+ mocks.executeInManualTransaction.mockResolvedValueOnce([{ columns: ["matches"], rows: [[1]] }]).mockResolvedValueOnce([{ affected_rows: 1 }]);+ const { editor } = createSaveTestEditor({ primaryKeys: [], ensureManualTransactionSession: vi.fn().mockResolvedValue("txn-grid-2") });+ editor.dirtyRows.value.set(0, new Map([[1, "shipped"]]));+ await editor.saveChanges();++ expect(mocks.executeInManualTransaction.mock.calls[0]?.[0]).toBe("txn-grid-2");+ expect(mocks.executeInManualTransaction.mock.calls[0]?.[1]).toBe(keylessGuard.sql);+ expect(mocks.executeInManualTransaction.mock.calls[1]?.[0]).toBe("txn-grid-2");+ expect(mocks.executeQuery).not.toHaveBeenCalled();+ expect(mocks.executeBatch).not.toHaveBeenCalled();+ });++ it("keeps edits pending if a manual transaction cannot start", async () => {+ mocks.prepareDataGridSave.mockResolvedValue({ statements: ["UPDATE orders_test SET status='shipped' WHERE id=1"], rollbackStatements: [] });+ const ensureManualTransactionSession = vi.fn().mockRejectedValue(new Error("BEGIN failed"));+ const { editor } = createSaveTestEditor({ ensureManualTransactionSession });+ editor.dirtyRows.value.set(0, new Map([[1, "shipped"]]));+ await editor.saveChanges();++ expect(editor.saveError.value).toContain("BEGIN failed");+ expect(editor.dirtyRows.value.get(0)?.get(1)).toBe("shipped");+ expect(mocks.executeBatch).not.toHaveBeenCalled();+ expect(mocks.executeInManualTransaction).not.toHaveBeenCalled();+ });+it("marks the manual transaction dirty before a result-grid mutation can fail", async () => {const onManualTransactionMutation = vi.fn();mocks.prepareDataGridSave.mockResolvedValue({ statements: ["UPDATE orders_test SET status='shipped' WHERE id=1"], rollbackStatements: [] });diff --git a/apps/desktop/src/composables/useDataGridEditor.ts b/apps/desktop/src/composables/useDataGridEditor.tsindex 30eda58851..3240971dd0 100644--- a/apps/desktop/src/composables/useDataGridEditor.ts+++ b/apps/desktop/src/composables/useDataGridEditor.ts@@ -109,6 +109,7 @@ export interface UseDataGridEditorOptions {onExecuteSql: ComputedRef<((sql: string) => Promise<void>) | undefined>;customSaveHandler?: ComputedRef<CustomSaveHandler | undefined>;manualTransactionSessionId?: ComputedRef<string | undefined>;+ ensureManualTransactionSession?: ComputedRef<(() => Promise<string>) | undefined>;onManualTransactionMutation?: () => void;sql: ComputedRef<string | undefined>;searchText: Ref<string>;@@ -1598,9 +1599,8 @@ export function useDataGridEditor(options: UseDataGridEditorOptions) {// A keyless save can only be trusted once the server confirms that each// predicate it sends addresses a single physical row; the loaded page cannot// see rows outside it. Returns the error to fail with, or undefined to allow.- async function verifyKeylessGuards(guards: DataGridSaveGuard[], executionSchema?: string) {+ async function verifyKeylessGuards(guards: DataGridSaveGuard[], executionSchema?: string, txnSessionId = manualTransactionSessionId.value) {if (!guards.length) return undefined;- const txnSessionId = manualTransactionSessionId.value;// Without a connection to count against there is no way to verify the// predicate, and an unverified keyless write is exactly what must not run.if (!hasBackendSaveTarget.value) return KEYLESS_GUARD_UNVERIFIED_ERROR;@@ -1948,8 +1948,19 @@ export function useDataGridEditor(options: UseDataGridEditorOptions) {return;}const rollbackStmts = preparedSave?.rollbackStatements ?? [];+ let txnSessionId = manualTransactionSessionId.value;+ if (options.ensureManualTransactionSession?.value && hasBackendSaveTarget.value) {+ try {+ txnSessionId = await options.ensureManualTransactionSession.value();+ if (!txnSessionId) throw new Error("Manual transaction session was not initialized");+ } catch (error) {+ saveError.value = normalizeDataGridSaveError(databaseType.value, error);+ await finishInterruptedSaveChanges(snapshot);+ return;+ }+ }try {- const guardError = await verifyKeylessGuards(preparedSave?.keylessGuards ?? [], preparedSave?.executionSchema);+ const guardError = await verifyKeylessGuards(preparedSave?.keylessGuards ?? [], preparedSave?.executionSchema, txnSessionId);if (guardError) {saveError.value = guardError;await finishInterruptedSaveChanges(snapshot);@@ -1991,10 +2002,10 @@ export function useDataGridEditor(options: UseDataGridEditorOptions) {statements: stmts,rollbackStatements: rollbackStmts,});- if (manualTransactionSessionId.value && hasBackendSaveTarget.value) {+ if (txnSessionId && hasBackendSaveTarget.value) {options.onManualTransactionMutation?.();try {- const results = await api.executeInManualTransaction(manualTransactionSessionId.value, stmts.join(";\n"), database.value ?? "", preparedSave?.executionSchema);+ const results = await api.executeInManualTransaction(txnSessionId, stmts.join(";\n"), database.value ?? "", preparedSave?.executionSchema);apiResult = {affected_rows: results.reduce((total, result) => total + (result.affected_rows ?? 0), 0),};@@ -2038,7 +2049,7 @@ export function useDataGridEditor(options: UseDataGridEditorOptions) {applyDirtyRowsToResult(snapshot);options.onResultPayloadMutated?.();let savedRowsRefreshed = false;- if (!joinedWriteTargets.value?.length && !manualTransactionSessionId.value && !shouldReloadAfterSave && snapshot.dirtyRows.size > 0 && options.refreshSavedRows) {+ if (!joinedWriteTargets.value?.length && !txnSessionId && !shouldReloadAfterSave && snapshot.dirtyRows.size > 0 && options.refreshSavedRows) {try {savedRowsRefreshed = await options.refreshSavedRows({dirtyRows: snapshot.dirtyRows,diff --git a/apps/desktop/src/stores/__tests__/queryStore.provenReadOnlyStickyState.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.provenReadOnlyStickyState.spec.tsindex b0a8457600..b745d0becd 100644--- a/apps/desktop/src/stores/__tests__/queryStore.provenReadOnlyStickyState.spec.ts+++ b/apps/desktop/src/stores/__tests__/queryStore.provenReadOnlyStickyState.spec.ts@@ -118,6 +118,122 @@ describe("queryStore Oracle/OceanBase manual-transaction sticky state (behaviorreturn tabId;}+ it("starts one session for a result-grid save before the next SQL execution", async () => {+ const { useQueryStore } = await import("@/stores/queryStore");+ const store = useQueryStore();+ const tabId = await setupManualTab(store);++ const sessionId = await store.ensureManualTransactionSession(tabId, "ORCL", "APP");+ expect(sessionId).toBe("txn-oracle");+ expect(mocks.beginManualTransaction).toHaveBeenCalledWith("oracle-1", "ORCL", "APP", undefined);+ expect(store.tabs.find((item) => item.id === tabId)?.txnSessionId).toBe("txn-oracle");+ await store.ensureManualTransactionSession(tabId, "ORCL", "APP");+ expect(mocks.beginManualTransaction).toHaveBeenCalledOnce();+ });++ it("rolls back a session opened after the tab leaves manual mode", async () => {+ let finishBegin!: (sessionId: string) => void;+ mocks.beginManualTransaction.mockReturnValue(+ new Promise<string>((resolve) => {+ finishBegin = resolve;+ }),+ );+ const { useQueryStore } = await import("@/stores/queryStore");+ const store = useQueryStore();+ const tabId = store.createTab("oracle-1", "ORCL", "Query", "query", "APP");+ store.setAutoCommit(tabId, false);++ const starting = store.ensureManualTransactionSession(tabId, "ORCL", "APP");+ store.setAutoCommit(tabId, true);+ finishBegin("txn-late");++ await expect(starting).rejects.toThrow("Query tab changed");+ expect(mocks.rollbackManualTransaction).toHaveBeenCalledWith("txn-late");+ expect(store.tabs.find((item) => item.id === tabId)?.txnSessionId).toBeUndefined();+ });++ it("rolls back a session opened for a database the tab has left", async () => {+ let finishBegin!: (sessionId: string) => void;+ mocks.beginManualTransaction.mockReturnValue(+ new Promise<string>((resolve) => {+ finishBegin = resolve;+ }),+ );+ const { useQueryStore } = await import("@/stores/queryStore");+ const store = useQueryStore();+ const tabId = store.createTab("oracle-1", "ORCL", "Query", "query");+ store.setAutoCommit(tabId, false);++ const starting = store.ensureManualTransactionSession(tabId, "ORCL");+ store.updateDatabase(tabId, "OTHER_DB");+ finishBegin("txn-old-database");++ await expect(starting).rejects.toThrow("Query tab changed");+ expect(mocks.rollbackManualTransaction).toHaveBeenCalledWith("txn-old-database");+ expect(store.tabs.find((item) => item.id === tabId)?.txnSessionId).toBeUndefined();+ });++ it("does not attach a pending session after leaving and returning to the same database", async () => {+ let finishBegin!: (sessionId: string) => void;+ mocks.beginManualTransaction.mockReturnValue(+ new Promise<string>((resolve) => {+ finishBegin = resolve;+ }),+ );+ const { useQueryStore } = await import("@/stores/queryStore");+ const store = useQueryStore();+ const tabId = store.createTab("oracle-1", "ORCL", "Query", "query");+ store.setAutoCommit(tabId, false);++ const starting = store.ensureManualTransactionSession(tabId, "ORCL");+ store.updateDatabase(tabId, "OTHER_DB");+ store.updateDatabase(tabId, "ORCL");+ finishBegin("txn-before-switch");++ await expect(starting).rejects.toThrow("Query tab changed");+ expect(mocks.rollbackManualTransaction).toHaveBeenCalledWith("txn-before-switch");+ expect(store.tabs.find((item) => item.id === tabId)?.txnSessionId).toBeUndefined();+ });++ it("rolls back a session opened for a catalog the tab has left", async () => {+ let finishBegin!: (sessionId: string) => void;+ mocks.beginManualTransaction.mockReturnValue(+ new Promise<string>((resolve) => {+ finishBegin = resolve;+ }),+ );+ const { useQueryStore } = await import("@/stores/queryStore");+ const store = useQueryStore();+ const tabId = store.createTab("oracle-1", "ORCL", "Query", "query");+ store.setAutoCommit(tabId, false);++ const starting = store.ensureManualTransactionSession(tabId, "ORCL");+ store.updateCatalog(tabId, "NEW_CATALOG", "ORCL");+ finishBegin("txn-old-catalog");++ await expect(starting).rejects.toThrow("Query tab changed");+ expect(mocks.rollbackManualTransaction).toHaveBeenCalledWith("txn-old-catalog");+ expect(store.tabs.find((item) => item.id === tabId)?.txnSessionId).toBeUndefined();+ });++ it("does not reuse a previous database's transaction while rollback is pending", async () => {+ mocks.beginManualTransaction.mockResolvedValueOnce("txn-old").mockResolvedValueOnce("txn-new");+ mocks.rollbackManualTransaction.mockReturnValueOnce(new Promise<void>(() => {}));+ const { useQueryStore } = await import("@/stores/queryStore");+ const store = useQueryStore();+ const tabId = store.createTab("oracle-1", "ORCL", "Query", "query");+ store.setAutoCommit(tabId, false);+ await store.ensureManualTransactionSession(tabId, "ORCL");++ store.updateDatabase(tabId, "OTHER_DB");+ const newSession = await store.ensureManualTransactionSession(tabId, "OTHER_DB");++ expect(newSession).toBe("txn-new");+ expect(mocks.rollbackManualTransaction).toHaveBeenCalledWith("txn-old");+ expect(mocks.beginManualTransaction).toHaveBeenNthCalledWith(2, "oracle-1", "OTHER_DB", undefined, undefined);+ expect(store.tabs.find((item) => item.id === tabId)?.txnSessionId).toBe("txn-new");+ });+it("sends classificationSql only for the initial Oracle manual execution", async () => {mocks.executeInManualTransaction.mockResolvedValue(cleanSelect());@@ -261,6 +377,54 @@ describe("queryStore Oracle/OceanBase manual-transaction sticky state (behaviorexpect(tab.txnPossiblyDirty).not.toBe(true);});+ it("does not replay an expired transaction's SQL after its database changes during recovery", async () => {+ let finishBegin!: (sessionId: string) => void;+ mocks.beginManualTransaction.mockResolvedValueOnce("txn-old").mockImplementationOnce(+ () =>+ new Promise<string>((resolve) => {+ finishBegin = resolve;+ }),+ );+ mocks.executeInManualTransaction.mockRejectedValueOnce(expiredTransactionError()).mockResolvedValueOnce(cleanSelect());+ const { useQueryStore } = await import("@/stores/queryStore");+ const store = useQueryStore();+ const tabId = await setupManualTab(store);++ const running = store.executeTabSql(tabId, "SELECT * FROM EMP");+ await vi.waitFor(() => expect(mocks.beginManualTransaction).toHaveBeenCalledTimes(2));+ store.updateDatabase(tabId, "OTHER_DB");+ finishBegin("txn-recovered-old-database");+ await running;++ expect(mocks.rollbackManualTransaction).toHaveBeenCalledWith("txn-recovered-old-database");+ expect(mocks.executeInManualTransaction).toHaveBeenCalledTimes(1);+ expect(store.tabs.find((item) => item.id === tabId)?.txnSessionId).toBeUndefined();+ expect(store.tabs.find((item) => item.id === tabId)?.result).toBeUndefined();+ });++ it("does not publish results from a database the tab has left", async () => {+ let finishQuery!: (results: StickyResult[]) => void;+ mocks.executeInManualTransaction.mockReturnValueOnce(+ new Promise<StickyResult[]>((resolve) => {+ finishQuery = resolve;+ }),+ );+ const { useQueryStore } = await import("@/stores/queryStore");+ const store = useQueryStore();+ const tabId = await setupManualTab(store);++ const running = store.executeTabSql(tabId, "SELECT * FROM EMP");+ await vi.waitFor(() => expect(mocks.executeInManualTransaction).toHaveBeenCalledTimes(1));+ store.updateDatabase(tabId, "OTHER_DB");+ finishQuery(cleanSelect());+ await running;++ const tab = store.tabs.find((item) => item.id === tabId)!;+ expect(tab.database).toBe("OTHER_DB");+ expect(tab.result).toBeUndefined();+ expect(tab.isExecuting).toBe(false);+ });+it("clears the sticky state together with the session on DBX rollback", async () => {mocks.executeInManualTransaction.mockResolvedValue(dirtyUpdate());diff --git a/apps/desktop/src/stores/queryStore.ts b/apps/desktop/src/stores/queryStore.tsindex b11304f534..5549efb290 100644--- a/apps/desktop/src/stores/queryStore.ts+++ b/apps/desktop/src/stores/queryStore.ts@@ -4661,9 +4661,52 @@ export const useQueryStore = defineStore("query", () => {}}+ const manualTransactionTargetEpochs = new WeakMap<QueryTab, number>();+ const pendingManualTransactionStarts = new Map<string, { epoch: number; promise: Promise<string> }>();++ function manualTransactionTargetEpoch(tab: QueryTab): number {+ return manualTransactionTargetEpochs.get(tab) ?? 0;+ }++ function invalidateManualTransactionTarget(tab: QueryTab) {+ manualTransactionTargetEpochs.set(tab, manualTransactionTargetEpoch(tab) + 1);+ }++ async function ensureManualTransactionSession(id: string, database: string, schema?: string, catalog?: string): Promise<string> {+ const tab = tabs.value.find((item) => item.id === id);+ if (!tab || tab.mode !== "query" || tab.autoCommit !== false || !tab.connectionId) {+ throw new Error("Manual transaction mode is no longer active for this query tab");+ }+ if (tab.txnSessionId) return tab.txnSessionId;+ const epoch = manualTransactionTargetEpoch(tab);+ const pending = pendingManualTransactionStarts.get(id);+ if (pending?.epoch === epoch) return pending.promise;++ const connectionId = tab.connectionId;+ const originalDatabase = tab.database;+ const originalCatalog = tab.catalog;+ const originalSchema = tab.schema;+ const start = api+ .beginManualTransaction(connectionId, database, schema, catalog)+ .then(async (sessionId) => {+ if (tabs.value.find((item) => item.id === id) !== tab || tab.autoCommit !== false || manualTransactionTargetEpoch(tab) !== epoch || tab.connectionId !== connectionId || tab.database !== originalDatabase || tab.catalog !== originalCatalog || tab.schema !== originalSchema) {+ await api.rollbackManualTransaction(sessionId);+ throw new Error("Query tab changed while the manual transaction was starting");+ }+ tab.txnSessionId = sessionId;+ return sessionId;+ })+ .finally(() => {+ if (pendingManualTransactionStarts.get(id)?.promise === start) pendingManualTransactionStarts.delete(id);+ });+ pendingManualTransactionStarts.set(id, { epoch, promise: start });+ return start;+ }+function setAutoCommit(id: string, autoCommit: boolean) {const tab = tabs.value.find((t) => t.id === id);if (tab) {+ if (tab.autoCommit !== autoCommit) invalidateManualTransactionTarget(tab);const wasManual = tab.autoCommit === false;tab.autoCommit = autoCommit;if (autoCommit && wasManual) {@@ -4701,6 +4744,7 @@ export const useQueryStore = defineStore("query", () => {}function rollbackTabTransaction(tab: QueryTab, options?: { resetAutoCommit?: boolean; resetAutoCommitDbType?: string }) {+ invalidateManualTransactionTarget(tab);if (tab.txnSessionId) void rollbackTransaction(tab.id);if (options?.resetAutoCommit) {// Callers switching a tab to another connection pass the target db type@@ -4727,11 +4771,11 @@ export const useQueryStore = defineStore("query", () => {async function rollbackTransaction(id: string) {const tab = tabs.value.find((t) => t.id === id);if (!tab?.txnSessionId) return;- try {- await api.rollbackManualTransaction(tab.txnSessionId);- } finally {- clearManualTransactionSession(tab);- }+ const sessionId = tab.txnSessionId;+ // Remove the old session before the backend responds: a target switch may+ // start a new transaction while this rollback is still in flight.+ clearManualTransactionSession(tab);+ await api.rollbackManualTransaction(sessionId);}function updateEditorViewport(id: string, viewport: { scrollTop: number; scrollLeft: number }) {@@ -6246,6 +6290,7 @@ export const useQueryStore = defineStore("query", () => {const executionEditorFingerprint = tab.mode === "query" ? sqlTextFingerprint(tab.sql) : undefined;const traceId = executionId.slice(0, 8);const startedAt = performance.now();+ const executionTargetEpoch = manualTransactionTargetEpoch(tab);const elapsed = () => `${Math.round(performance.now() - startedAt)}ms`;const batchResume = options?.batchResume;const continueOnBatchError = batchResume?.continueOnError ?? settingsStore.editorSettings.continueOnErrorOnBatch;@@ -7101,7 +7146,7 @@ export const useQueryStore = defineStore("query", () => {const sourceLabelDatabase = targetDatabase || conn?.database;const executionClientSessionId = options?.pagination?.clientSessionId ?? (tab.mode === "query" || tab.mode === "data" ? tabClientSessionId(tab) : undefined);const currentBeforeDispatch = findExecutionTab(id);- if (currentBeforeDispatch?.executionId !== executionId || currentBeforeDispatch.isCancelling) {+ if (currentBeforeDispatch?.executionId !== executionId || currentBeforeDispatch.isCancelling || manualTransactionTargetEpoch(currentBeforeDispatch) !== executionTargetEpoch) {queryExecutionLog("info", "dispatch:skipped-cancelled", { traceId, elapsed: elapsed() });return false;}@@ -7199,7 +7244,7 @@ export const useQueryStore = defineStore("query", () => {if (!tab.txnSessionId) {queryExecutionLog("info", "begin-manual-txn:start", { traceId, elapsed: elapsed() });try {- tab.txnSessionId = await api.beginManualTransaction(executionConnectionId, executionDatabase, executionSchema, executionCatalog);+ tab.txnSessionId = await ensureManualTransactionSession(id, executionDatabase, executionSchema, executionCatalog);queryExecutionLog("info", "begin-manual-txn:done", { traceId, txnSessionId: tab.txnSessionId, elapsed: elapsed() });} catch (error) {const risk = classifySqlRisk(sqlToExecute, { dialect: effectiveDbType }).risk;@@ -7240,6 +7285,7 @@ export const useQueryStore = defineStore("query", () => {return await executeInTransaction(txnSessionId);} catch (error) {if (options?.pagination?.sessionId || manualTransactionRecoveryAttempted || !isManualTransactionSessionExpired(error)) throw error;+ if (tab.executionId !== executionId || tab.autoCommit !== false || manualTransactionTargetEpoch(tab) !== executionTargetEpoch) throw error;manualTransactionRecoveryAttempted = true;// The expired session was discarded by the backend; the replacement// session starts fresh, so the old sticky state resets with it.@@ -7247,7 +7293,12 @@ export const useQueryStore = defineStore("query", () => {tab.txnSessionId = undefined;tab.txnAutoRolledBack = true;queryExecutionLog("info", "manual-txn:expired-recover", { traceId, elapsed: elapsed() });- const refreshedSessionId = await api.beginManualTransaction(executionConnectionId, executionDatabase, executionSchema, executionCatalog);+ const refreshedSessionId = await ensureManualTransactionSession(id, executionDatabase, executionSchema, executionCatalog);+ if (tab.executionId !== executionId || tab.autoCommit !== false || manualTransactionTargetEpoch(tab) !== executionTargetEpoch) {+ if (tab.txnSessionId === refreshedSessionId) clearManualTransactionSession(tab);+ await api.rollbackManualTransaction(refreshedSessionId);+ throw new Error("Query tab changed while the manual transaction was restarting");+ }tab.txnSessionId = refreshedSessionId;queryExecutionLog("info", "manual-txn:restarted", { traceId, txnSessionId: refreshedSessionId, elapsed: elapsed() });return executeInTransaction(refreshedSessionId);@@ -7257,20 +7308,11 @@ export const useQueryStore = defineStore("query", () => {} else {executionPromise = executeWithoutManualTransaction();}- const annotatedResults = annotateQueryResultSources(- markQueryResultsRowsRaw(- await withFrontendQueryTimeout(executionPromise, frontendTimeoutSecs, t("editor.queryTimeoutError", { seconds: frontendTimeoutSecs }), () => {- void api.cancelQuery(executionId).catch((error) => queryExecutionLog("warn", "frontend-timeout:cancel-failed", { traceId, error }));- }),- ),- queryBaseSql,- sourceLabelDatabase,- effectiveDbType,- options?.sourceOffset,- sqlStatementParameterOptions,- sqlToExecute,- options?.sourceOffset === undefined ? undefined : tab.sql,- );+ const responseResults = await withFrontendQueryTimeout(executionPromise, frontendTimeoutSecs, t("editor.queryTimeoutError", { seconds: frontendTimeoutSecs }), () => {+ void api.cancelQuery(executionId).catch((error) => queryExecutionLog("warn", "frontend-timeout:cancel-failed", { traceId, error }));+ });+ if (findExecutionTab(id) !== tab || tab.executionId !== executionId || manualTransactionTargetEpoch(tab) !== executionTargetEpoch) return false;+ const annotatedResults = annotateQueryResultSources(markQueryResultsRowsRaw(responseResults), queryBaseSql, sourceLabelDatabase, effectiveDbType, options?.sourceOffset, sqlStatementParameterOptions, sqlToExecute, options?.sourceOffset === undefined ? undefined : tab.sql);const results = offsetBatchQueryResultIndexes(annotatedResults.results, batchResume?.startStatementIndex ?? 0);if (paginationRowNumberColumn && results.length === 1) {results[0] = markQueryResultsRowsRaw([stripPaginationRowNumber(results[0]!, paginationRowNumberColumn)])[0]!;@@ -7319,7 +7361,7 @@ export const useQueryStore = defineStore("query", () => {}}const current = findExecutionTab(id);- if (current?.executionId === executionId) {+ if (current?.executionId === executionId && manualTransactionTargetEpoch(current) === executionTargetEpoch) {if (captureResultRun && current.isCancelling && restorePendingResultRun(current, executionId)) return false;if (successfulOracleSchemaChanges > 0) {current.completionContextVersion = (current.completionContextVersion ?? 0) + successfulOracleSchemaChanges;@@ -7503,6 +7545,7 @@ export const useQueryStore = defineStore("query", () => {queryExecutionLog("error", "error", { traceId, elapsed: elapsed(), error: e });// Sync connection state if the error indicates a lost connectionuseConnectionStore().recordConnectionLostError(executionConnectionId ?? tab.connectionId, e);+ if (findExecutionTab(id) !== tab || tab.executionId !== executionId || manualTransactionTargetEpoch(tab) !== executionTargetEpoch) return false;// Handle manual transaction auto-rollback (idle timeout only for the banner;// other statement failures still clear the session without the 5-minute notice).if (tab.autoCommit === false) {@@ -8802,6 +8845,7 @@ export const useQueryStore = defineStore("query", () => {markManualTransactionDirty,commitTransaction,rollbackTransaction,+ ensureManualTransactionSession,renameTab,openDatabaseBrowser,openDriverProfileWorkspace,