From bd05c0350d27a8382b88d19e2102f73bce16da6a Mon Sep 17 00:00:00 2001
From: Abeautifulsnow <lcprunstone@163.com>
Date: Thu, 27 Aug 2026 11:30:27 +0800
Subject: [PATCH] feat(oracle): hide commit/rollback for clean
 manual-transaction state

---
 apps/desktop/src/App.vue                      |   8 +
 .../src/components/layout/EditorToolbar.vue   |  20 +-
 .../EditorToolbar.transactionMode.spec.ts     |   9 +
 apps/desktop/src/lib/backend/http.ts          |   2 +-
 apps/desktop/src/lib/backend/tauri.ts         |   3 +-
 .../queryStore.hiddenPrimaryKey.spec.ts       |   8 +-
 .../queryStore.oracleTxnStickyState.spec.ts   | 343 ++++++++++++++++++
 apps/desktop/src/stores/queryStore.ts         |  61 +++-
 apps/desktop/src/types/database.ts            |  11 +
 crates/dbx-core/src/query.rs                  | 108 +++++-
 crates/dbx-core/src/query_execution_sql.rs    | 174 +++++++++
 crates/dbx-web/src/routes/query.rs            |   2 +
 src-tauri/src/commands/query.rs               |   2 +
 13 files changed, 729 insertions(+), 22 deletions(-)
 create mode 100644 apps/desktop/src/stores/__tests__/queryStore.oracleTxnStickyState.spec.ts

diff --git a/apps/desktop/src/App.vue b/apps/desktop/src/App.vue
index 5654dffb51..3a2f3e4ff5 100644
--- a/apps/desktop/src/App.vue
+++ b/apps/desktop/src/App.vue
@@ -341,6 +341,12 @@ const activeConnection = computed(() => {
   return tab ? connectionStore.getConfig(tab.connectionId) : undefined;
 });
 
+// Oracle manual-mode indicator derived from the RESOLVED database type (an
+// Oracle connection uses the agent runtime but reports db_type "oracle"), so
+// the toolbar's Commit/Rollback visibility can apply the Oracle dirty-state rule
+// without inferring Oracle from the raw transport type.
+const isOracleManualTransaction = computed(() => effectiveDatabaseTypeForConnection(activeConnection.value) === "oracle" && (activeTab.value?.autoCommit ?? true) === false);
+
 function updateAgentDriverUpdateCount(count: number) {
   if (!settingsStore.editorSettings.updateNotificationsEnabled) {
     agentDriverUpdateCount.value = 0;
@@ -3039,6 +3045,8 @@ onUnmounted(() => {
                   :auto-commit="activeTab.autoCommit ?? true"
                   :txn-session-id="activeTab?.txnSessionId"
                   :txn-auto-rolled-back="activeTab?.txnAutoRolledBack"
+                  :oracle-txn-possibly-dirty="activeTab?.oracleTxnPossiblyDirty"
+                  :is-oracle-manual-transaction="isOracleManualTransaction"
                   @update:explain-mode="(m: 'explain' | 'autotrace') => (explainMode = m)"
                   @update:block-dangerous-redis-commands="(v: boolean) => (blockDangerousRedisCommands = v)"
                   @update:auto-commit="
diff --git a/apps/desktop/src/components/layout/EditorToolbar.vue b/apps/desktop/src/components/layout/EditorToolbar.vue
index 8995f44761..6db03688a6 100644
--- a/apps/desktop/src/components/layout/EditorToolbar.vue
+++ b/apps/desktop/src/components/layout/EditorToolbar.vue
@@ -34,6 +34,12 @@ const props = defineProps<{
   autoCommit?: boolean;
   txnSessionId?: string;
   txnAutoRolledBack?: boolean;
+  /** Oracle-only: whether the current manual Oracle session executed a statement
+   *  DBX cannot prove read-only. Commit/Rollback are hidden while false. */
+  oracleTxnPossiblyDirty?: boolean;
+  /** Oracle manual mode derived from the resolved database type (not raw
+   *  db_type, which can be the agent transport). */
+  isOracleManualTransaction?: boolean;
 }>();
 
 const emit = defineEmits<{
@@ -153,6 +159,12 @@ function toggleSqlSemanticDiagnostics() {
 const isTransactionActive = computed(() => !!props.txnSessionId);
 const isManualTransactionMode = computed(() => props.autoCommit === false || isTransactionActive.value);
 const transactionModeBadge = computed(() => (isManualTransactionMode.value ? "M" : "A"));
+// Oracle manual mode hides Commit/Rollback while the session is clean (no
+// unproven statement executed). Every other database keeps the existing rule.
+const showTxnActions = computed(() => {
+  if (props.isOracleManualTransaction) return isTransactionActive.value && props.oracleTxnPossiblyDirty === true;
+  return isTransactionActive.value;
+});
 const transactionTooltip = computed(() => {
   const isAgent = (props.activeConnection?.db_type as string) === "agent";
   const isManual = isManualTransactionMode.value;
@@ -430,8 +442,8 @@ async function changeCatalog(selectedCatalog: string) {
           </TooltipTrigger>
           <TooltipContent>{{ transactionTooltip }}</TooltipContent>
         </Tooltip>
-        <!-- Commit button (only when transaction is active) -->
-        <Tooltip v-if="isTransactionActive">
+        <!-- Commit button (only when a transaction action is warranted) -->
+        <Tooltip v-if="showTxnActions">
           <TooltipTrigger as-child>
             <Button variant="ghost" size="icon" class="h-6 w-6 text-green-600 hover:bg-green-500/10 hover:text-green-700 dark:text-green-300 dark:hover:text-green-200" :disabled="activeTab.isExecuting" :aria-label="t('toolbar.commit')" @click="emit('commit')">
               <Check class="h-3.5 w-3.5" />
@@ -440,8 +452,8 @@ async function changeCatalog(selectedCatalog: string) {
           <TooltipContent>{{ t("toolbar.commit") }}</TooltipContent>
         </Tooltip>
 
-        <!-- Rollback button (only when transaction is active) -->
-        <Tooltip v-if="isTransactionActive">
+        <!-- Rollback button (only when a transaction action is warranted) -->
+        <Tooltip v-if="showTxnActions">
           <TooltipTrigger as-child>
             <Button variant="ghost" size="icon" class="h-6 w-6 text-red-600 hover:bg-red-500/10 hover:text-red-700 dark:text-red-300 dark:hover:text-red-200" :disabled="activeTab.isExecuting" :aria-label="t('toolbar.rollback')" @click="emit('rollback')">
               <RotateCcw class="h-3.5 w-3.5" />
diff --git a/apps/desktop/src/components/layout/__tests__/EditorToolbar.transactionMode.spec.ts b/apps/desktop/src/components/layout/__tests__/EditorToolbar.transactionMode.spec.ts
index aaf3a8c44f..5ae419030b 100644
--- a/apps/desktop/src/components/layout/__tests__/EditorToolbar.transactionMode.spec.ts
+++ b/apps/desktop/src/components/layout/__tests__/EditorToolbar.transactionMode.spec.ts
@@ -31,4 +31,13 @@ describe("EditorToolbar transaction mode control", () => {
     expect(rollbackIndex).toBeGreaterThan(commitIndex);
     expect(actionGroupEndIndex).toBeGreaterThan(rollbackIndex);
   });
+
+  it("hides Commit/Rollback for a clean Oracle manual session only", () => {
+    expect(toolbarSource).toContain("const showTxnActions = computed(() => {");
+    expect(toolbarSource).toContain("if (props.isOracleManualTransaction) return isTransactionActive.value && props.oracleTxnPossiblyDirty === true;");
+    expect(toolbarSource).toContain("return isTransactionActive.value;");
+    // Both buttons are driven by the combined condition.
+    expect(toolbarSource).toContain('<Tooltip v-if="showTxnActions">');
+    expect(toolbarSource.match(/<Tooltip v-if="showTxnActions">/g)).toHaveLength(2);
+  });
 });
diff --git a/apps/desktop/src/lib/backend/http.ts b/apps/desktop/src/lib/backend/http.ts
index 7a289feab9..b12aaa41d3 100644
--- a/apps/desktop/src/lib/backend/http.ts
+++ b/apps/desktop/src/lib/backend/http.ts
@@ -1253,7 +1253,7 @@ export async function beginManualTransaction(_connectionId: string, _database: s
   throw new Error("Manual transaction management is only available in the desktop app.");
 }
 
-export async function executeInManualTransaction(_txnSessionId: string, _sql: string, _database: string, _schema?: string, _maxRows?: number, _tableDataPreview?: boolean, _pageSize?: number, _resultSessionId?: string): Promise<QueryResult[]> {
+export async function executeInManualTransaction(_txnSessionId: string, _sql: string, _database: string, _schema?: string, _maxRows?: number, _tableDataPreview?: boolean, _pageSize?: number, _resultSessionId?: string, _classificationSql?: string): Promise<QueryResult[]> {
   throw new Error("Manual transaction management is only available in the desktop app.");
 }
 
diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.ts
index f8dc125ccf..0c90b2b2e5 100644
--- a/apps/desktop/src/lib/backend/tauri.ts
+++ b/apps/desktop/src/lib/backend/tauri.ts
@@ -1482,7 +1482,7 @@ export async function beginManualTransaction(connectionId: string, database: str
   return invoke("begin_manual_transaction", { connectionId, database, schema, catalog });
 }
 
-export async function executeInManualTransaction(txnSessionId: string, sql: string, database: string, schema?: string, maxRows?: number, tableDataPreview?: boolean, pageSize?: number, resultSessionId?: string): Promise<QueryResult[]> {
+export async function executeInManualTransaction(txnSessionId: string, sql: string, database: string, schema?: string, maxRows?: number, tableDataPreview?: boolean, pageSize?: number, resultSessionId?: string, classificationSql?: string): Promise<QueryResult[]> {
   return invoke("execute_in_manual_transaction", {
     txnSessionId,
     sql,
@@ -1492,6 +1492,7 @@ export async function executeInManualTransaction(txnSessionId: string, sql: stri
     tableDataPreview,
     pageSize,
     resultSessionId,
+    classificationSql,
   });
 }
 
diff --git a/apps/desktop/src/stores/__tests__/queryStore.hiddenPrimaryKey.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.hiddenPrimaryKey.spec.ts
index 563293adbc..4241ab388a 100644
--- a/apps/desktop/src/stores/__tests__/queryStore.hiddenPrimaryKey.spec.ts
+++ b/apps/desktop/src/stores/__tests__/queryStore.hiddenPrimaryKey.spec.ts
@@ -844,7 +844,7 @@ describe("queryStore hidden primary key editing", () => {
     await execution;
 
     expect(beginManualTransaction).toHaveBeenCalledWith("oracle-1", "ORCL", undefined, undefined);
-    expect(executeInManualTransaction).toHaveBeenCalledWith("txn-1", "SELECT t.* FROM APP.WIDE_TABLE t", "ORCL", undefined, expect.any(Number), true);
+    expect(executeInManualTransaction).toHaveBeenCalledWith("txn-1", "SELECT t.* FROM APP.WIDE_TABLE t", "ORCL", undefined, expect.any(Number), true, undefined, undefined, "SELECT t.* FROM APP.WIDE_TABLE t");
     expect(store.tabs.find((tab) => tab.id === tabId)?.result?.large_value_cells).toEqual([{ row_index: 0, column_index: 1, original_bytes: 81920 }]);
   });
 
@@ -890,7 +890,7 @@ describe("queryStore hidden primary key editing", () => {
     await store.executeTabSql(tabId, sql);
     const tab = store.tabs.find((item) => item.id === tabId)!;
     expect(tab.autoCommit).toBe(false);
-    expect(executeInManualTransaction).toHaveBeenNthCalledWith(1, "txn-1", sql, "ORCL", undefined, expect.any(Number), false, 100, undefined);
+    expect(executeInManualTransaction).toHaveBeenNthCalledWith(1, "txn-1", sql, "ORCL", undefined, expect.any(Number), false, 100, undefined, sql);
     expect(tab.result?.rows).toHaveLength(100);
 
     await store.executeTabSql(tabId, sql, {
@@ -902,7 +902,7 @@ describe("queryStore hidden primary key editing", () => {
       replaceActiveResultInGroup: true,
     });
 
-    expect(executeInManualTransaction).toHaveBeenNthCalledWith(2, "txn-1", sql, "ORCL", undefined, expect.any(Number), false, 100, "oracle-go-1");
+    expect(executeInManualTransaction).toHaveBeenNthCalledWith(2, "txn-1", sql, "ORCL", undefined, expect.any(Number), false, 100, "oracle-go-1", undefined);
     expect(tab.result?.rows).toHaveLength(200);
     expect(tab.result?.rows[100]).toEqual([101]);
   });
@@ -959,7 +959,7 @@ describe("queryStore hidden primary key editing", () => {
 
     await store.executeTabSql(tabId, "SELECT name FROM users");
 
-    expect(executeInManualTransaction).toHaveBeenCalledWith("txn-1", "SELECT name, `id` AS `__DBX_PK_0` FROM users", "app", undefined, expect.any(Number), false);
+    expect(executeInManualTransaction).toHaveBeenCalledWith("txn-1", "SELECT name, `id` AS `__DBX_PK_0` FROM users", "app", undefined, expect.any(Number), false, undefined, undefined, undefined);
   });
 
   it("keeps a keyless Oracle query editable when its WHERE clause reads another table", async () => {
diff --git a/apps/desktop/src/stores/__tests__/queryStore.oracleTxnStickyState.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.oracleTxnStickyState.spec.ts
new file mode 100644
index 0000000000..cc19473b0f
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/queryStore.oracleTxnStickyState.spec.ts
@@ -0,0 +1,343 @@
+import { createPinia, setActivePinia } from "pinia";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  analyzeEditableQueryEditability: vi.fn(),
+  beginManualTransaction: vi.fn(),
+  closeClientConnectionSession: vi.fn(),
+  closeQuerySession: vi.fn(),
+  commitManualTransaction: vi.fn(),
+  executeInManualTransaction: vi.fn(),
+  executeMulti: vi.fn(),
+  getConnectionConfig: vi.fn(),
+  prepareQueryPaginationExecutionPlan: vi.fn(),
+  rollbackManualTransaction: vi.fn(),
+  saveOpenTabsState: vi.fn(),
+}));
+
+vi.mock("@/lib/backend/api", () => ({
+  analyzeEditableQueryEditability: mocks.analyzeEditableQueryEditability,
+  beginManualTransaction: mocks.beginManualTransaction,
+  closeClientConnectionSession: mocks.closeClientConnectionSession,
+  closeQuerySession: mocks.closeQuerySession,
+  commitManualTransaction: mocks.commitManualTransaction,
+  executeInManualTransaction: mocks.executeInManualTransaction,
+  executeMulti: mocks.executeMulti,
+  prepareQueryPaginationExecutionPlan: mocks.prepareQueryPaginationExecutionPlan,
+  rollbackManualTransaction: mocks.rollbackManualTransaction,
+  saveOpenTabsState: mocks.saveOpenTabsState,
+}));
+
+vi.mock("@/stores/connectionStore", () => ({
+  useConnectionStore: () => ({
+    ensureConnected: vi.fn().mockResolvedValue(undefined),
+    getConfig: mocks.getConnectionConfig,
+    recordConnectionLostError: vi.fn(),
+  }),
+}));
+
+vi.mock("@/stores/settingsStore", () => ({
+  useSettingsStore: () => ({
+    editorSettings: {
+      autoCalculateTotalRows: false,
+      continueOnErrorOnBatch: false,
+      pageSize: 100,
+      queryResultMaxRowsEnabled: false,
+      queryResultMaxRows: 1000,
+      openTabsRestoreMode: "all",
+      confirmUnsavedSqlClose: false,
+    },
+  }),
+}));
+
+function installLocalStorage() {
+  const data = new Map<string, string>();
+  vi.stubGlobal("localStorage", {
+    getItem: vi.fn((key: string) => data.get(key) ?? null),
+    setItem: vi.fn((key: string, value: string) => data.set(key, value)),
+    removeItem: vi.fn((key: string) => data.delete(key)),
+  });
+}
+
+type OracleResult = Record<string, unknown>;
+
+function cleanSelect(): OracleResult[] {
+  return [{ columns: ["VALUE"], rows: [[1]], affected_rows: 0, execution_time_ms: 1, manual_transaction_proven_read_only: true }];
+}
+
+function dirtyUpdate(): OracleResult[] {
+  return [{ columns: [], rows: [], affected_rows: 1, execution_time_ms: 1 }];
+}
+
+function noOpResult(): OracleResult[] {
+  return [{ columns: [], rows: [], affected_rows: 0, execution_time_ms: 1, manual_transaction_no_statement: true }];
+}
+
+function expiredTransactionError() {
+  return {
+    version: 1 as const,
+    code: "DBX-TXN-1001",
+    messageKey: "backendErrors.transaction.sessionExpired",
+    messageParams: { timeoutSecs: 300 },
+    source: "legacyBackend" as const,
+    operationOutcome: "not_started" as const,
+    origin: { subsystem: "database", adapter: "native" },
+    diagnostics: { category: "transaction", stage: "execute" },
+  };
+}
+
+describe("queryStore Oracle manual-transaction sticky state", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.unstubAllGlobals();
+    installLocalStorage();
+    setActivePinia(createPinia());
+    mocks.getConnectionConfig.mockReturnValue({
+      id: "oracle-1",
+      name: "Oracle",
+      db_type: "oracle",
+      database: "ORCL",
+      query_timeout_secs: 30,
+    });
+    mocks.prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({
+      sqlToExecute: options.sql,
+      pageSql: undefined,
+      pageLimit: undefined,
+      pageOffset: undefined,
+      countSql: undefined,
+      useAgentResultSession: false,
+    }));
+    mocks.analyzeEditableQueryEditability.mockResolvedValue({ editable: false, reason: "not-select" });
+    mocks.saveOpenTabsState.mockResolvedValue(undefined);
+  });
+
+  async function setupManualTab(store: { createTab: (c: string, d: string, t: string, m: string, s: string) => string }, _sql = "SELECT * FROM EMP") {
+    mocks.beginManualTransaction.mockResolvedValue("txn-oracle");
+    const tabId = store.createTab("oracle-1", "ORCL", "Query", "query", "APP");
+    store.setAutoCommit(tabId, false);
+    return tabId;
+  }
+
+  it("sends classificationSql only for the initial Oracle manual execution", async () => {
+    mocks.executeInManualTransaction.mockResolvedValue(cleanSelect());
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = await setupManualTab(store);
+
+    await store.executeTabSql(tabId, "SELECT * FROM EMP");
+
+    expect(mocks.executeInManualTransaction).toHaveBeenCalledOnce();
+    const args = mocks.executeInManualTransaction.mock.calls[0]!;
+    expect(args[0]).toBe("txn-oracle");
+    // classificationSql is the last argument of the non-cursor branch.
+    expect(args.at(-1)).toBe("SELECT * FROM EMP");
+  });
+
+  it("keeps a clean Oracle manual session clean after a proven simple SELECT", async () => {
+    mocks.executeInManualTransaction.mockResolvedValue(cleanSelect());
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = await setupManualTab(store);
+
+    await store.executeTabSql(tabId, "SELECT * FROM EMP");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.oracleTxnPossiblyDirty).not.toBe(true);
+    expect(tab.txnSessionId).toBe("txn-oracle");
+  });
+
+  it("dirties an Oracle manual session after an UPDATE", async () => {
+    mocks.executeInManualTransaction.mockResolvedValue(dirtyUpdate());
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = await setupManualTab(store);
+
+    await store.executeTabSql(tabId, "UPDATE EMP SET DEPTNO = 10");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.oracleTxnPossiblyDirty).toBe(true);
+  });
+
+  it("never clears the sticky state after a later read (UPDATE -> SELECT)", async () => {
+    mocks.executeInManualTransaction.mockResolvedValueOnce(dirtyUpdate()).mockResolvedValueOnce(cleanSelect());
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = await setupManualTab(store);
+
+    await store.executeTabSql(tabId, "UPDATE EMP SET DEPTNO = 10");
+    await store.executeTabSql(tabId, "SELECT * FROM EMP");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.oracleTxnPossiblyDirty).toBe(true);
+  });
+
+  it("dirties the session for any unproven statement in a mixed script", async () => {
+    mocks.executeInManualTransaction.mockResolvedValue([
+      { columns: ["VALUE"], rows: [[1]], affected_rows: 0, execution_time_ms: 1, manual_transaction_proven_read_only: true },
+      { columns: [], rows: [], affected_rows: 1, execution_time_ms: 1 },
+    ]);
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = await setupManualTab(store);
+
+    await store.executeTabSql(tabId, "SELECT * FROM DUAL; DELETE FROM EMP");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.oracleTxnPossiblyDirty).toBe(true);
+  });
+
+  it("treats a Core no-op result as neither dirty nor clean-changing", async () => {
+    mocks.executeInManualTransaction.mockResolvedValueOnce(noOpResult()).mockResolvedValueOnce(noOpResult());
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = await setupManualTab(store);
+
+    // Empty script keeps dirty undefined; then a real clean select still stays clean.
+    await store.executeTabSql(tabId, "  -- only a comment\n");
+    await store.executeTabSql(tabId, "SELECT * FROM EMP");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.oracleTxnPossiblyDirty).not.toBe(true);
+  });
+
+  it("passes no classificationSql and changes no sticky state on a cursor-page fetch", async () => {
+    mocks.executeInManualTransaction.mockResolvedValueOnce(dirtyUpdate()).mockResolvedValueOnce(cleanSelect());
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = await setupManualTab(store);
+
+    await store.executeTabSql(tabId, "UPDATE EMP SET DEPTNO = 10");
+
+    // Simulate a later page fetch of a clean result.
+    mocks.executeInManualTransaction.mockClear();
+    mocks.executeInManualTransaction.mockResolvedValue(cleanSelect());
+    await store.executeTabSql(tabId, "SELECT * FROM EMP", {
+      pagination: { sessionId: "cursor-1", clientSessionId: "client-1", limit: 100, offset: 100 },
+    });
+
+    const args = mocks.executeInManualTransaction.mock.calls[0]!;
+    // Page fetch carries no classificationSql (last argument), so it cannot
+    // change the sticky bit.
+    expect(args.at(-1)).toBeUndefined();
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    // Page fetch must neither set nor clear the dirty bit.
+    expect(tab.oracleTxnPossiblyDirty).toBe(true);
+  });
+
+  it("resets the sticky state on session-expiry recovery and recomputes from the retry", async () => {
+    mocks.beginManualTransaction.mockResolvedValueOnce("txn-old").mockResolvedValueOnce("txn-new");
+    mocks.executeInManualTransaction.mockResolvedValueOnce(dirtyUpdate()).mockRejectedValueOnce(expiredTransactionError()).mockResolvedValueOnce(cleanSelect());
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = await setupManualTab(store);
+
+    await store.executeTabSql(tabId, "UPDATE EMP SET DEPTNO = 10");
+    await store.executeTabSql(tabId, "SELECT * FROM EMP");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.txnSessionId).toBe("txn-new");
+    expect(tab.oracleTxnPossiblyDirty).not.toBe(true);
+  });
+
+  it("clears the sticky state together with the session on DBX rollback", async () => {
+    mocks.executeInManualTransaction.mockResolvedValue(dirtyUpdate());
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = await setupManualTab(store);
+
+    await store.executeTabSql(tabId, "UPDATE EMP SET DEPTNO = 10");
+    await store.rollbackTransaction(tabId);
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.txnSessionId).toBeUndefined();
+    expect(tab.oracleTxnPossiblyDirty).not.toBe(true);
+  });
+
+  it("clears session and sticky state when a statement failure disposes the manual session", async () => {
+    mocks.executeInManualTransaction.mockResolvedValueOnce(dirtyUpdate()).mockRejectedValueOnce(new Error("Statement 1 failed: ORA-02292 integrity constraint violated. The manual transaction was rolled back."));
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = await setupManualTab(store);
+
+    await store.executeTabSql(tabId, "UPDATE EMP SET DEPTNO = 10");
+    await store.executeTabSql(tabId, "DELETE FROM EMP WHERE DEPTNO = 99");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    // The `rolled back` fragment is the cleanup compatibility contract: the
+    // backend removed the manual session, so both fields must reset with it.
+    expect(tab.txnSessionId).toBeUndefined();
+    expect(tab.oracleTxnPossiblyDirty).not.toBe(true);
+    expect(tab.txnAutoRolledBack).not.toBe(true);
+  });
+
+  it("dirties a clean session when a frontend timeout rejects while the manual session survives", async () => {
+    mocks.executeInManualTransaction.mockRejectedValueOnce(new Error("Query timed out after 30 seconds"));
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = await setupManualTab(store);
+
+    await store.executeTabSql(tabId, "UPDATE EMP SET DEPTNO = 10");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    // The statement may still have executed server-side while the manual
+    // session survives, so the sticky state must stay fail-closed dirty.
+    expect(tab.txnSessionId).toBe("txn-oracle");
+    expect(tab.oracleTxnPossiblyDirty).toBe(true);
+  });
+
+  it("keeps a clean session clean when a cursor-page fetch times out", async () => {
+    mocks.executeInManualTransaction.mockResolvedValueOnce(cleanSelect()).mockRejectedValueOnce(new Error("Query timed out after 30 seconds"));
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = await setupManualTab(store);
+
+    await store.executeTabSql(tabId, "SELECT * FROM EMP");
+    await store.executeTabSql(tabId, "SELECT * FROM EMP", {
+      pagination: { sessionId: "cursor-1", clientSessionId: "client-1", limit: 100, offset: 100 },
+    });
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    // Page fetches never participate in the sticky state, matching aggregation.
+    expect(tab.txnSessionId).toBe("txn-oracle");
+    expect(tab.oracleTxnPossiblyDirty).not.toBe(true);
+  });
+
+  it("leaves non-Oracle manual sessions using the old rule and no marker handling", async () => {
+    mocks.getConnectionConfig.mockReturnValue({
+      id: "pg-1",
+      name: "Postgres",
+      db_type: "postgres",
+      database: "postgres",
+      query_timeout_secs: 30,
+    });
+    mocks.beginManualTransaction.mockResolvedValue("txn-pg");
+    // A Postgres manual execution never returns the Oracle marker.
+    mocks.executeInManualTransaction.mockResolvedValue([{ columns: [], rows: [], affected_rows: 0, execution_time_ms: 1 }]);
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("pg-1", "postgres", "Query", "query", "public");
+    store.setAutoCommit(tabId, false);
+
+    await store.executeTabSql(tabId, "SELECT 1");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    // No classificationSql was sent and no Oracle sticky state exists.
+    const args = mocks.executeInManualTransaction.mock.calls[0]!;
+    expect(args.at(-1)).toBeUndefined();
+    expect(tab.oracleTxnPossiblyDirty).toBeUndefined();
+    expect(tab.txnSessionId).toBe("txn-pg");
+  });
+});
diff --git a/apps/desktop/src/stores/queryStore.ts b/apps/desktop/src/stores/queryStore.ts
index 79fa337c5c..f48f89a483 100644
--- a/apps/desktop/src/stores/queryStore.ts
+++ b/apps/desktop/src/stores/queryStore.ts
@@ -3243,18 +3243,36 @@ export const useQueryStore = defineStore("query", () => {
         if (tab.txnSessionId) {
           void rollbackTransaction(id);
         } else {
-          tab.txnAutoRolledBack = false;
+          clearManualTransactionSession(tab);
         }
       }
     }
   }
 
+  /** Reset only the Oracle sticky-dirty bit. Used when a session continues but
+   *  the old dirty state must be discarded (e.g. idle-expiry recovery where the
+   *  replacement session starts fresh). Full session cleanup goes through
+   *  `clearManualTransactionSession`. */
+  function clearOracleTxnPossiblyDirty(tab: { oracleTxnPossiblyDirty?: boolean }) {
+    if (tab.oracleTxnPossiblyDirty !== undefined) tab.oracleTxnPossiblyDirty = false;
+  }
+
+  /** Centralized manual-session cleanup. Clears every field tied to a manual
+   *  transaction session exactly when that session is conclusively ended or
+   *  discarded. Callers must not assign these fields individually. */
+  function clearManualTransactionSession(tab: QueryTab) {
+    tab.txnSessionId = undefined;
+    tab.txnAutoRolledBack = false;
+    if (tab.oracleTxnPossiblyDirty !== undefined) tab.oracleTxnPossiblyDirty = false;
+  }
+
   function rollbackTabTransaction(tab: QueryTab, options?: { resetAutoCommit?: boolean }) {
     if (tab.txnSessionId) void rollbackTransaction(tab.id);
     if (options?.resetAutoCommit) {
       const dbType = useConnectionStore().getConfig(tab.connectionId)?.db_type;
       tab.autoCommit = defaultAutoCommitForDbType(dbType);
     }
+    clearOracleTxnPossiblyDirty(tab);
     tab.txnAutoRolledBack = false;
   }
 
@@ -3264,8 +3282,7 @@ export const useQueryStore = defineStore("query", () => {
     try {
       await api.commitManualTransaction(tab.txnSessionId);
     } finally {
-      tab.txnSessionId = undefined;
-      tab.txnAutoRolledBack = false;
+      clearManualTransactionSession(tab);
     }
   }
 
@@ -3275,8 +3292,7 @@ export const useQueryStore = defineStore("query", () => {
     try {
       await api.rollbackManualTransaction(tab.txnSessionId);
     } finally {
-      tab.txnSessionId = undefined;
-      tab.txnAutoRolledBack = false;
+      clearManualTransactionSession(tab);
     }
   }
 
@@ -5242,19 +5258,26 @@ export const useQueryStore = defineStore("query", () => {
         }
         queryExecutionLog("info", "execute-in-txn:invoke", { traceId, txnSessionId: tab.txnSessionId, elapsed: elapsed() });
         executionDispatched = true;
+        // Only an initial manual execution classifies the user SQL (Oracle-only).
+        // A later cursor-page fetch must neither set nor clear the sticky bit.
+        const isInitialOracleManualExecution = effectiveDbType === "oracle" && !options?.pagination?.sessionId;
+        const classificationSql = isInitialOracleManualExecution ? queryBaseSql : undefined;
         let manualTransactionRecoveryAttempted = false;
         executionPromise = (async () => {
           const txnSessionId = tab.txnSessionId;
           if (!txnSessionId) throw new Error("Manual transaction session was not initialized");
           const executeInTransaction = (sessionId: string) =>
             useAgentResultSession
-              ? api.executeInManualTransaction(sessionId, sqlToExecute, executionDatabase, executionSchema, agentProtocolQueryResultMaxRows(queryResultMaxRows), useOracleLobPreview, pageLimit, options?.pagination?.sessionId)
-              : api.executeInManualTransaction(sessionId, sqlToExecute, executionDatabase, executionSchema, pageLimit ?? agentProtocolQueryResultMaxRows(queryResultMaxRows), useOracleLobPreview);
+              ? api.executeInManualTransaction(sessionId, sqlToExecute, executionDatabase, executionSchema, agentProtocolQueryResultMaxRows(queryResultMaxRows), useOracleLobPreview, pageLimit, options?.pagination?.sessionId, classificationSql)
+              : api.executeInManualTransaction(sessionId, sqlToExecute, executionDatabase, executionSchema, pageLimit ?? agentProtocolQueryResultMaxRows(queryResultMaxRows), useOracleLobPreview, undefined, undefined, classificationSql);
           try {
             return await executeInTransaction(txnSessionId);
           } catch (error) {
             if (options?.pagination?.sessionId || manualTransactionRecoveryAttempted || !isManualTransactionSessionExpired(error)) 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.
+            clearOracleTxnPossiblyDirty(tab);
             tab.txnSessionId = undefined;
             tab.txnAutoRolledBack = true;
             queryExecutionLog("info", "manual-txn:expired-recover", { traceId, elapsed: elapsed() });
@@ -5325,6 +5348,18 @@ export const useQueryStore = defineStore("query", () => {
       const annotatedResults = annotateQueryResultSources(markQueryResultsRowsRaw(await withFrontendQueryTimeout(executionPromise, frontendTimeoutSecs, t("editor.queryTimeoutError", { seconds: frontendTimeoutSecs }))), queryBaseSql, sourceLabelDatabase, effectiveDbType, options?.sourceOffset);
       const results = offsetBatchQueryResultIndexes(annotatedResults.results, batchResume?.startStatementIndex ?? 0);
       reconcileBatchSqlResults(tab, executionId, results);
+      // Oracle-only sticky state aggregation. Only the initial manual execution
+      // participates: a later cursor-page fetch (pagination.sessionId present)
+      // must neither set nor clear the bit, and the Core no-op (empty script)
+      // must neither set nor clear it. Otherwise any result that is not proven
+      // read-only dirties the session monotonically.
+      if (tab.autoCommit === false && effectiveDbType === "oracle" && !options?.pagination?.sessionId && tab.txnSessionId) {
+        const rawResults = annotatedResults.results;
+        const isCoreNoOp = rawResults.length > 0 && rawResults.every((result) => result.manual_transaction_no_statement === true);
+        if (!isCoreNoOp && rawResults.some((result) => result.manual_transaction_proven_read_only !== true)) {
+          tab.oracleTxnPossiblyDirty = true;
+        }
+      }
       const successfulOracleSchemaChanges = effectiveDbType === "oracle" ? results.filter((result) => result.execution_error !== true && isOracleCurrentSchemaStatement(result.sourceStatement)).length : 0;
       const successfulSapHanaSchemaChanges = effectiveDbType === "saphana" ? results.filter((result) => result.execution_error !== true && isSapHanaSetSchemaStatement(result.sourceStatement)).length : 0;
       const sqlServerUseDatabase = effectiveDbType === "sqlserver" ? annotatedResults.sqlServerUseDatabase : undefined;
@@ -5532,11 +5567,23 @@ export const useQueryStore = defineStore("query", () => {
         const errMsg: string = e?.message ?? String(e);
         const idleTimeout = /5 minutes of inactivity/i.test(errMsg) || errMsg.includes("5 分钟无操作") || errMsg.includes("已自动回滚");
         if (idleTimeout) {
+          // Backend session was removed and rolled back after idle expiry: clear
+          // the sticky dirty state together with the session.
+          clearOracleTxnPossiblyDirty(tab);
           tab.txnSessionId = undefined;
           tab.txnAutoRolledBack = true;
         } else if (/rolled.?back/i.test(errMsg) || /transaction session not found/i.test(errMsg) || /agent runtime terminated/i.test(errMsg)) {
+          // Statement failure that disposed the manual session: the `rolled back`
+          // message fragment is a frontend cleanup compatibility contract.
+          clearOracleTxnPossiblyDirty(tab);
           tab.txnSessionId = undefined;
           tab.txnAutoRolledBack = false;
+        } else if (tab.txnSessionId && executionDispatched && !options?.pagination?.sessionId && effectiveDatabaseTypeForConnection(useConnectionStore().getConfig(tab.connectionId)) === "oracle") {
+          // Frontend timeout/cancel or mid-script failure: the statement may still
+          // have executed server-side while the manual session survives, so keep
+          // the sticky dirty state fail-closed instead of a clean toolbar on a
+          // dirty session. Cursor-page fetches stay excluded like the aggregation.
+          tab.oracleTxnPossiblyDirty = true;
         }
       }
       const current = findExecutionTab(id);
diff --git a/apps/desktop/src/types/database.ts b/apps/desktop/src/types/database.ts
index 0eb9620025..30203bee51 100644
--- a/apps/desktop/src/types/database.ts
+++ b/apps/desktop/src/types/database.ts
@@ -646,6 +646,13 @@ export interface QueryResult {
   execution_error?: true;
   /** Set only for SQL Server informational messages emitted by the backend. */
   server_message?: true;
+  /** Oracle-only manual-transaction UX marker: set on a manual-transaction result
+   *  whose statement DBX proved to be an ordinary top-level read. Absent for
+   *  every non-Oracle execution and every unproven Oracle statement. */
+  manual_transaction_proven_read_only?: true;
+  /** Oracle-only manual-transaction UX marker: set on the synthetic successful
+   *  result of an empty/whitespace/comments-only manual script. */
+  manual_transaction_no_statement?: true;
   /** Structured backend error; authoritative when execution_error is true. */
   error?: BackendError;
   /** Zero-based index of the submitted statement that produced this result. */
@@ -1311,6 +1318,10 @@ export interface QueryTab {
   txnSessionId?: string;
   /** Set to true when a manual transaction was auto-rolled back due to inactivity */
   txnAutoRolledBack?: boolean;
+  /** Oracle-only, non-persisted: whether the current manual Oracle session has
+   *  executed at least one statement DBX cannot prove read-only. Commit/Rollback
+   *  actions are hidden while a session is clean. Never cleared by a later read. */
+  oracleTxnPossiblyDirty?: boolean;
 }
 
 export interface SavedSqlFolder {
diff --git a/crates/dbx-core/src/query.rs b/crates/dbx-core/src/query.rs
index 61e3ab9f75..fa8c222b27 100644
--- a/crates/dbx-core/src/query.rs
+++ b/crates/dbx-core/src/query.rs
@@ -23,7 +23,7 @@ use crate::database_capabilities;
 use crate::db;
 use crate::db::agent_driver::{AgentCallError, AgentErrorStage, AgentOperationOutcome};
 use crate::models::connection::{ConnectionConfig, DatabaseType};
-use crate::query_execution_sql::{is_write_sql, strip_sql_comments_and_literals};
+use crate::query_execution_sql::{is_oracle_proven_read_only_statement, is_write_sql, strip_sql_comments_and_literals};
 use crate::sql::{split_sql_batches, split_sql_statements, starts_with_executable_sql_keyword_for_database};
 use crate::sql_dialect::{resolve_for_db, CAP_TRANSACTIONAL_DDL};
 use crate::sql_risk::{classify_sql_risk_for_database, SqlRisk};
@@ -197,6 +197,18 @@ pub struct ExecuteMultiResult {
     pub error: Option<crate::backend_error::BackendError>,
     #[serde(skip_serializing_if = "is_false")]
     pub server_message: bool,
+    /// Oracle-only manual-transaction UX metadata: true only for a statement
+    /// proven to be an ordinary top-level read. Absent/false for every other
+    /// Oracle statement and every non-Oracle execution. Not part of the
+    /// reusable database-result model (`db::QueryResult`).
+    #[serde(skip_serializing_if = "is_false")]
+    pub manual_transaction_proven_read_only: bool,
+    /// Oracle-only manual-transaction UX metadata: true on the synthetic
+    /// successful result when the manual-execution splitter found zero
+    /// statements (empty/whitespace/comments-only script). Lets the frontend
+    /// treat it as a no-op rather than an unproven statement.
+    #[serde(skip_serializing_if = "is_false")]
+    pub manual_transaction_no_statement: bool,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -243,6 +255,8 @@ impl ExecuteMultiResult {
             statement_index: None,
             error,
             server_message: false,
+            manual_transaction_proven_read_only: false,
+            manual_transaction_no_statement: false,
         }
     }
 
@@ -256,6 +270,8 @@ impl ExecuteMultiResult {
             statement_index: Some(statement_index),
             error,
             server_message: false,
+            manual_transaction_proven_read_only: false,
+            manual_transaction_no_statement: false,
         }
     }
 
@@ -271,6 +287,8 @@ impl ExecuteMultiResult {
             statement_index,
             error: Some(error),
             server_message: false,
+            manual_transaction_proven_read_only: false,
+            manual_transaction_no_statement: false,
         }
     }
 
@@ -282,6 +300,8 @@ impl ExecuteMultiResult {
             statement_index: Some(statement_index),
             error: None,
             server_message: false,
+            manual_transaction_proven_read_only: false,
+            manual_transaction_no_statement: false,
         }
     }
 
@@ -304,6 +324,8 @@ impl ExecuteMultiResult {
             statement_index: Some(statement_index),
             error: None,
             server_message: false,
+            manual_transaction_proven_read_only: false,
+            manual_transaction_no_statement: false,
         }
     }
 
@@ -325,9 +347,21 @@ impl ExecuteMultiResult {
             statement_index: None,
             error: None,
             server_message: false,
+            manual_transaction_proven_read_only: false,
+            manual_transaction_no_statement: false,
         }
     }
 
+    fn with_manual_transaction_proven_read_only(mut self) -> Self {
+        self.manual_transaction_proven_read_only = true;
+        self
+    }
+
+    fn with_manual_transaction_no_statement(mut self) -> Self {
+        self.manual_transaction_no_statement = true;
+        self
+    }
+
     pub fn without_error_detail(mut self) -> Self {
         self.error = self.error.map(crate::backend_error::BackendError::without_detail);
         self
@@ -600,6 +634,8 @@ impl From<db::QueryResult> for ExecuteMultiResult {
             statement_index: None,
             error: None,
             server_message: false,
+            manual_transaction_proven_read_only: false,
+            manual_transaction_no_statement: false,
         }
     }
 }
@@ -613,6 +649,8 @@ impl From<db::sqlserver::SqlServerBatchResult> for ExecuteMultiResult {
             statement_index: None,
             error: None,
             server_message: result.server_message,
+            manual_transaction_proven_read_only: false,
+            manual_transaction_no_statement: false,
         }
     }
 }
@@ -4597,6 +4635,12 @@ pub struct ManualTransactionExecutionOptions {
     pub table_data_preview: bool,
     pub page_size: Option<usize>,
     pub result_session_id: Option<String>,
+    /// User-facing SQL to classify (Oracle-only). When present, the core
+    /// classifies each split statement of this SQL rather than the rewritten
+    /// execution SQL, pairing them by count and position so DBX-owned
+    /// read-preserving rewrites (hidden primary keys, sort wrappers,
+    /// pagination) do not change toolbar semantics. Fail-closed on mismatch.
+    pub classification_sql: Option<String>,
 }
 
 pub async fn execute_in_manual_transaction_with_options(
@@ -4624,10 +4668,18 @@ pub async fn execute_in_manual_transaction_with_options(
         |db_type| crate::sql::split_sql_statements_for_database(sql, db_type),
     );
     if statements.is_empty() {
-        return Ok(vec![ExecuteMultiResult::success_with_optional_server_large_values(
+        // Oracle-only UX marker: the no-op is Core's decision that the script
+        // (empty/whitespace/comments-only) has no statements, so the frontend
+        // must not treat it as an unproven statement. Every other database
+        // receives the plain empty result.
+        let mut result = ExecuteMultiResult::success_with_optional_server_large_values(
             empty_query_result(0),
             options.table_data_preview,
-        )]);
+        );
+        if db_type == Some(DatabaseType::Oracle) {
+            result = result.with_manual_transaction_no_statement();
+        }
+        return Ok(vec![result]);
     }
     // A result-session cursor can only track one result set, so pagination is
     // single-statement only. Multi-statement scripts predate pagination: keep
@@ -4680,6 +4732,30 @@ pub async fn execute_in_manual_transaction_with_options(
     let row_limit = options.max_rows.unwrap_or(MAX_ROWS).max(1);
     let mut results = Vec::with_capacity(statements.len());
 
+    // Oracle-only classification pairing. The core splits both the execution
+    // SQL and, when present, the user-facing classification SQL with the same
+    // Oracle-aware splitter. A marker is emitted only when both lists have the
+    // same non-zero count and every paired user statement is proven read-only;
+    // any mismatch is fail-closed (no marker). This is deliberately a
+    // trust-boundary count/position pairing, not a SQL-equivalence parser.
+    let classification: Vec<bool> = if db_type == Some(DatabaseType::Oracle) {
+        match options.classification_sql.as_deref() {
+            Some(classification_sql) => {
+                let user_statements =
+                    crate::sql::split_sql_statements_for_database(classification_sql, DatabaseType::Oracle);
+                let paired = user_statements.len() == statements.len() && !user_statements.is_empty();
+                if paired {
+                    user_statements.iter().map(|statement| is_oracle_proven_read_only_statement(statement)).collect()
+                } else {
+                    Vec::new()
+                }
+            }
+            None => Vec::new(),
+        }
+    } else {
+        Vec::new()
+    };
+
     let mut conn = connection.lock().await;
     for (i, statement) in statements.iter().enumerate() {
         let result = match &mut *conn {
@@ -4708,10 +4784,14 @@ pub async fn execute_in_manual_transaction_with_options(
         };
         match result {
             Ok(query_result) => {
-                results.push(ExecuteMultiResult::success_with_optional_server_large_values(
+                let mut executed = ExecuteMultiResult::success_with_optional_server_large_values(
                     query_result,
                     options.table_data_preview,
-                ));
+                );
+                if classification.get(i).copied().unwrap_or(false) {
+                    executed = executed.with_manual_transaction_proven_read_only();
+                }
+                results.push(executed);
             }
             Err(e) => {
                 // Statement failure ends the transaction. If another cleanup path
@@ -5320,6 +5400,24 @@ mod tests {
         assert!(!postgres_prefers_text_protocol(None));
     }
 
+    #[test]
+    fn execute_multi_result_manual_transaction_markers_serialize_conditionally() {
+        let plain = ExecuteMultiResult::success_with_optional_server_large_values(empty_query_result(0), false);
+        let plain_value = serde_json::to_value(&plain).unwrap();
+        assert!(plain_value.get("manual_transaction_proven_read_only").is_none());
+        assert!(plain_value.get("manual_transaction_no_statement").is_none());
+
+        let proven = plain.clone().with_manual_transaction_proven_read_only();
+        let proven_value = serde_json::to_value(&proven).unwrap();
+        assert_eq!(proven_value.get("manual_transaction_proven_read_only"), Some(&serde_json::Value::Bool(true)));
+        assert!(proven_value.get("manual_transaction_no_statement").is_none());
+
+        let no_statement = plain.with_manual_transaction_no_statement();
+        let no_statement_value = serde_json::to_value(&no_statement).unwrap();
+        assert_eq!(no_statement_value.get("manual_transaction_no_statement"), Some(&serde_json::Value::Bool(true)));
+        assert!(no_statement_value.get("manual_transaction_proven_read_only").is_none());
+    }
+
     #[test]
     fn schema_diff_destructive_detection_covers_drop_and_alter_drop() {
         assert!(is_destructive_schema_diff_statement("DROP INDEX idx_users_email ON users"));
diff --git a/crates/dbx-core/src/query_execution_sql.rs b/crates/dbx-core/src/query_execution_sql.rs
index c85da3abeb..2fb79dc545 100644
--- a/crates/dbx-core/src/query_execution_sql.rs
+++ b/crates/dbx-core/src/query_execution_sql.rs
@@ -590,6 +590,93 @@ pub fn check_read_only(sql: &str, connection_name: &str, database_type: Database
     Ok(())
 }
 
+/// Oracle-only, fail-closed classifier for manual-transaction UX. Returns true
+/// only for an ordinary top-level read that DBX can prove harmless: a single
+/// top-level `SELECT` (not `WITH`) that after Oracle-aware comment/literal
+/// stripping contains no row-locking, transaction-control, DDL/DCL, `CALL`/
+/// `EXEC`, PL/SQL block, `EXECUTE IMMEDIATE`, database-link, sequence
+/// pseudocolumn (`NEXTVAL`/`CURRVAL`), function-invocation, or subquery
+/// syntax. Any lexical ambiguity is **not** proven read-only; the classifier
+/// deliberately whitelists no functions because user/package function side
+/// effects cannot be proven and would create an unbounded compatibility
+/// surface.
+pub fn is_oracle_proven_read_only_statement(sql: &str) -> bool {
+    let cleaned = strip_sql_comments_and_literals(sql);
+    let trimmed = cleaned.trim_start();
+    if trimmed.is_empty() {
+        return false;
+    }
+    let upper = trimmed.to_uppercase();
+    // Single top-level SELECT only (WITH is excluded because data-modifying
+    // CTEs can hide writes in a row-returning path).
+    if !starts_with_keyword(&upper, "SELECT") {
+        return false;
+    }
+
+    let lower = cleaned.to_lowercase();
+
+    // Function invocation or subquery syntax: any '(' after literal stripping.
+    // This deliberately excludes SELECT upper(name), COUNT(*), package
+    // functions, and subqueries DBX cannot prove harmless.
+    if lower.contains('(') {
+        return false;
+    }
+
+    // Database link: '@' cannot appear in an unquoted Oracle identifier, so any
+    // remaining '@' after literal stripping is a remote-object reference.
+    if lower.contains('@') {
+        return false;
+    }
+
+    // Word-boundary forbidden keywords. These are Oracle keywords/reserved
+    // words, so they cannot be legitimate unquoted identifiers inside a simple
+    // read; a quoted occurrence is already stripped to spaces above.
+    const FORBIDDEN_WORDS: &[&str] = &[
+        // row locking
+        "for",
+        "update",
+        "lock",
+        // transaction control
+        "begin",
+        "commit",
+        "rollback",
+        "savepoint",
+        // DDL/DCL
+        "create",
+        "alter",
+        "drop",
+        "truncate",
+        "rename",
+        "grant",
+        "revoke",
+        "comment",
+        "purge",
+        "audit",
+        "noaudit",
+        "analyze",
+        "flashback",
+        "merge",
+        "insert",
+        "delete",
+        // set operators (a UNION is not a single top-level SELECT)
+        "union",
+        "minus",
+        "intersect",
+        // stored procedures / dynamic SQL / PL/SQL blocks
+        "call",
+        "exec",
+        "execute",
+        "declare",
+        // sequence pseudocolumns
+        "nextval",
+        "currval",
+        // SELECT ... INTO is PL/SQL-only in Oracle
+        "into",
+    ];
+
+    !FORBIDDEN_WORDS.iter().any(|word| contains_word(&lower, word))
+}
+
 fn contains_word(source: &str, word: &str) -> bool {
     let bytes = source.as_bytes();
     let word_bytes = word.as_bytes();
@@ -825,6 +912,93 @@ where
 mod tests {
     use super::*;
 
+    #[test]
+    fn oracle_proven_read_only_accepts_simple_top_level_selects() {
+        assert!(is_oracle_proven_read_only_statement("SELECT * FROM table"));
+        assert!(is_oracle_proven_read_only_statement("select id, name from users"));
+        assert!(is_oracle_proven_read_only_statement("SELECT * FROM users WHERE id = 1"));
+        assert!(is_oracle_proven_read_only_statement("SELECT * FROM users ORDER BY id"));
+        assert!(is_oracle_proven_read_only_statement("SELECT * FROM users FETCH FIRST 10 ROWS ONLY"));
+        assert!(is_oracle_proven_read_only_statement("SELECT 1"));
+        assert!(is_oracle_proven_read_only_statement("SELECT ROWNUM FROM dual"));
+        assert!(is_oracle_proven_read_only_statement("SELECT * FROM users"));
+        // Comment/literal stripping hides keywords that are not part of the SQL.
+        assert!(is_oracle_proven_read_only_statement("-- comment\nSELECT * FROM users"));
+        assert!(is_oracle_proven_read_only_statement("SELECT 'update' FROM dual"));
+        assert!(is_oracle_proven_read_only_statement("SELECT \"select\" FROM t"));
+        assert!(is_oracle_proven_read_only_statement("SELECT * FROM user_update"));
+    }
+
+    #[test]
+    fn oracle_proven_read_only_rejects_writes_and_ddl() {
+        for sql in [
+            "UPDATE users SET name = 'x'",
+            "INSERT INTO users VALUES (1)",
+            "DELETE FROM users",
+            "MERGE INTO target USING source ON (a = b) WHEN MATCHED THEN UPDATE",
+            "CREATE TABLE t (id INT)",
+            "ALTER TABLE t ADD COLUMN c INT",
+            "DROP TABLE t",
+            "TRUNCATE TABLE t",
+            "GRANT SELECT ON t TO x",
+            "REVOKE SELECT ON t FROM x",
+        ] {
+            assert!(!is_oracle_proven_read_only_statement(sql), "expected rejected: {sql}");
+        }
+    }
+
+    #[test]
+    fn oracle_proven_read_only_rejects_cte_procedure_and_plsql() {
+        for sql in [
+            "WITH cte AS (SELECT 1 FROM dual) SELECT * FROM cte",
+            "CALL my_proc()",
+            "EXEC my_proc",
+            "EXECUTE IMMEDIATE 'DROP TABLE t'",
+            "BEGIN UPDATE t SET x = 1; END;",
+            "DECLARE x INT; BEGIN NULL; END;",
+        ] {
+            assert!(!is_oracle_proven_read_only_statement(sql), "expected rejected: {sql}");
+        }
+    }
+
+    #[test]
+    fn oracle_proven_read_only_rejects_locking_and_sequence_pseudocolumns() {
+        for sql in [
+            "SELECT * FROM t FOR UPDATE",
+            "LOCK TABLE t IN EXCLUSIVE MODE",
+            "SELECT seq.NEXTVAL FROM dual",
+            "SELECT seq.CURRVAL FROM dual",
+            "SELECT * FROM t@dblink",
+            "SELECT * FROM t WHERE id = 1 FOR UPDATE",
+        ] {
+            assert!(!is_oracle_proven_read_only_statement(sql), "expected rejected: {sql}");
+        }
+    }
+
+    #[test]
+    fn oracle_proven_read_only_rejects_functions_and_subqueries() {
+        for sql in [
+            "SELECT upper(name) FROM users",
+            "SELECT count(*) FROM users",
+            "SELECT pkg.fn() FROM dual",
+            "SELECT * FROM users WHERE id IN (SELECT id FROM orders)",
+            "SELECT * FROM (SELECT * FROM users)",
+            "SELECT NVL(name, 'x') FROM users",
+        ] {
+            assert!(!is_oracle_proven_read_only_statement(sql), "expected rejected: {sql}");
+        }
+    }
+
+    #[test]
+    fn oracle_proven_read_only_rejects_empty_and_ambiguous_input() {
+        assert!(!is_oracle_proven_read_only_statement(""));
+        assert!(!is_oracle_proven_read_only_statement("   "));
+        assert!(!is_oracle_proven_read_only_statement("-- only a comment"));
+        assert!(!is_oracle_proven_read_only_statement("SELECT * FROM t WHERE a IN (1, 2)"));
+        assert!(!is_oracle_proven_read_only_statement("SELECT * FROM t WHERE b = 'x' AND c IN (3)"));
+        assert!(!is_oracle_proven_read_only_statement("SELECT 1 UNION SELECT 2"));
+    }
+
     #[test]
     fn builds_postgres_json_explain_sql() {
         let result = build_explain_sql(ExplainSqlOptions {
diff --git a/crates/dbx-web/src/routes/query.rs b/crates/dbx-web/src/routes/query.rs
index a0a3cd32e4..bcb4f9baae 100644
--- a/crates/dbx-web/src/routes/query.rs
+++ b/crates/dbx-web/src/routes/query.rs
@@ -1308,6 +1308,8 @@ mod tests {
                 "relation customer_orders does not exist",
             )),
             server_message: false,
+            manual_transaction_proven_read_only: false,
+            manual_transaction_no_statement: false,
         };
 
         let response = execute_multi_response(vec![result], 17).unwrap();
diff --git a/src-tauri/src/commands/query.rs b/src-tauri/src/commands/query.rs
index cdac5e0bb6..79b7f274a2 100644
--- a/src-tauri/src/commands/query.rs
+++ b/src-tauri/src/commands/query.rs
@@ -465,6 +465,7 @@ pub async fn execute_in_manual_transaction(
     table_data_preview: Option<bool>,
     page_size: Option<usize>,
     result_session_id: Option<String>,
+    classification_sql: Option<String>,
 ) -> Result<Vec<dbx_core::query::ExecuteMultiResult>, ManualTransactionCommandError> {
     dbx_core::query::execute_in_manual_transaction_with_options(
         &state,
@@ -477,6 +478,7 @@ pub async fn execute_in_manual_transaction(
             table_data_preview: table_data_preview.unwrap_or(false),
             page_size,
             result_session_id,
+            classification_sql,
         },
     )
     .await