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): support manual transaction control in oracle mode
zipg2b1c5fa71eb2
diff --git a/agents/common/src/main/java/com/dbx/agent/AbstractJdbcAgent.java b/agents/common/src/main/java/com/dbx/agent/AbstractJdbcAgent.javaindex 0f65d08c6f..8006768c7a 100644--- a/agents/common/src/main/java/com/dbx/agent/AbstractJdbcAgent.java+++ b/agents/common/src/main/java/com/dbx/agent/AbstractJdbcAgent.java@@ -255,13 +255,19 @@ public abstract class AbstractJdbcAgent extends BaseDatabaseAgent {@Overridepublic QueryResult executeTransaction(List<String> statements, String schema) {- return TransactionExecutor.executeUpdateStatements(- requireConnected(),- statements,- schema,- this::setSchemaSQL,- this::resetSchemaSQL- );+ Connection conn = requireConnected();+ return unchecked(() -> {+ if (!conn.getAutoCommit()) {+ throw new IllegalStateException("Cannot start a one-shot transaction while a manual transaction is open");+ }+ return TransactionExecutor.executeUpdateStatements(+ conn,+ statements,+ schema,+ this::setSchemaSQL,+ this::resetSchemaSQL+ );+ });}@Override@@ -377,7 +383,9 @@ public abstract class AbstractJdbcAgent extends BaseDatabaseAgent {JdbcExecutor executor,boolean succeeded,boolean requiresSessionAffinity,- boolean evictAfterRequest+ boolean evictAfterRequest,+ boolean endsSessionAffinity,+ boolean preservesSchemaContext) {if (poolRegistry == null) {return;@@ -389,7 +397,12 @@ public abstract class AbstractJdbcAgent extends BaseDatabaseAgent {}if (succeeded && requiresSessionAffinity) {sessionAffinity = true;- JdbcSchemaSwitcher.forget(connection);+ if (!preservesSchemaContext) {+ JdbcSchemaSwitcher.forget(connection);+ }+ }+ if (succeeded && endsSessionAffinity) {+ sessionAffinity = false;}if (pooledLease == null) {connection = null;diff --git a/agents/common/src/main/java/com/dbx/agent/DatabaseAgent.java b/agents/common/src/main/java/com/dbx/agent/DatabaseAgent.javaindex 7f7e79095e..81eae8898e 100644--- a/agents/common/src/main/java/com/dbx/agent/DatabaseAgent.java+++ b/agents/common/src/main/java/com/dbx/agent/DatabaseAgent.java@@ -224,13 +224,71 @@ public interface DatabaseAgent {if (conn == null) {throw new IllegalStateException("Not connected");}- return TransactionExecutor.executeUpdateStatements(- conn,- statements,- schema,- this::setSchemaSQL,- this::resetSchemaSQL- );+ return unchecked(() -> {+ if (!conn.getAutoCommit()) {+ throw new IllegalStateException("Cannot start a one-shot transaction while a manual transaction is open");+ }+ return TransactionExecutor.executeUpdateStatements(+ conn,+ statements,+ schema,+ this::setSchemaSQL,+ this::resetSchemaSQL+ );+ });+ }++ /** Starts an interactive transaction on the current JDBC connection. */+ default Map<String, Object> beginManualTransaction(String schema) {+ Connection conn = getConnection();+ if (conn == null) {+ throw new IllegalStateException("Not connected");+ }+ return unchecked(() -> {+ if (!conn.getAutoCommit()) {+ throw new IllegalStateException("Manual transaction already open");+ }+ if (schema != null && !schema.trim().isEmpty()) {+ JdbcSchemaSwitcher.apply(conn, schema, this::setSchemaSQL, this::resetSchemaSQL);+ }+ conn.setAutoCommit(false);+ JdbcSchemaSwitcher.preserve(conn);+ return Collections.singletonMap("ok", (Object) true);+ });+ }++ /** Commits an interactive transaction on the current JDBC connection. */+ default Map<String, Object> commitManualTransaction() {+ Connection conn = getConnection();+ if (conn == null) {+ throw new IllegalStateException("Not connected");+ }+ return unchecked(() -> {+ if (conn.getAutoCommit()) {+ throw new IllegalStateException("No manual transaction open");+ }+ conn.commit();+ conn.setAutoCommit(true);+ JdbcSchemaSwitcher.releasePreserved(conn);+ return Collections.singletonMap("ok", (Object) true);+ });+ }++ /** Rolls back an interactive transaction on the current JDBC connection. */+ default Map<String, Object> rollbackManualTransaction() {+ Connection conn = getConnection();+ if (conn == null) {+ throw new IllegalStateException("Not connected");+ }+ return unchecked(() -> {+ if (conn.getAutoCommit()) {+ throw new IllegalStateException("No manual transaction open");+ }+ conn.rollback();+ conn.setAutoCommit(true);+ JdbcSchemaSwitcher.releasePreserved(conn);+ return Collections.singletonMap("ok", (Object) true);+ });}default QueryResult executeBatch(List<String> statements, String schema) {diff --git a/agents/common/src/main/java/com/dbx/agent/JdbcSchemaSwitcher.java b/agents/common/src/main/java/com/dbx/agent/JdbcSchemaSwitcher.javaindex 9afc686fe2..7d6675e953 100644--- a/agents/common/src/main/java/com/dbx/agent/JdbcSchemaSwitcher.java+++ b/agents/common/src/main/java/com/dbx/agent/JdbcSchemaSwitcher.java@@ -12,6 +12,8 @@ import java.util.function.Supplier;final class JdbcSchemaSwitcher {private static final Map<Connection, ResetState> RESET_STATE_BY_CONNECTION =Collections.synchronizedMap(new WeakHashMap<>());+ private static final Map<Connection, Boolean> PRESERVED_BY_CONNECTION =+ Collections.synchronizedMap(new WeakHashMap<>());private JdbcSchemaSwitcher() {}@@ -27,6 +29,9 @@ final class JdbcSchemaSwitcher {Supplier<String> resetSchemaSql) throws Exception {if (schema == null || schema.trim().isEmpty()) {+ if (isPreserved(conn)) {+ return;+ }if (!restore(conn, true)) {throw new SQLException("Failed to restore the original JDBC schema context");}@@ -70,7 +75,20 @@ final class JdbcSchemaSwitcher {RESET_STATE_BY_CONNECTION.remove(conn);}+ static void preserve(Connection conn) {+ PRESERVED_BY_CONNECTION.put(conn, Boolean.TRUE);+ }++ static void releasePreserved(Connection conn) {+ PRESERVED_BY_CONNECTION.remove(conn);+ }++ private static boolean isPreserved(Connection conn) {+ return PRESERVED_BY_CONNECTION.containsKey(conn);+ }+private static boolean restore(Connection conn, boolean preserveOnFailure) {+ PRESERVED_BY_CONNECTION.remove(conn);ResetState resetState = RESET_STATE_BY_CONNECTION.remove(conn);if (resetState == null) {return true;diff --git a/agents/common/src/main/java/com/dbx/agent/JsonRpcServer.java b/agents/common/src/main/java/com/dbx/agent/JsonRpcServer.javaindex 7af6257a04..7a267fbe97 100644--- a/agents/common/src/main/java/com/dbx/agent/JsonRpcServer.java+++ b/agents/common/src/main/java/com/dbx/agent/JsonRpcServer.java@@ -111,7 +111,9 @@ public final class JsonRpcServer {jdbcExecutor,succeeded,requiresSessionAffinity(method, params),- evictAfterRequest(method)+ evictAfterRequest(method),+ endsSessionAffinity(method),+ preservesSchemaContext());}}@@ -315,6 +317,15 @@ public final class JsonRpcServer {List<String> statements = gson.fromJson(params.get("statements"), statementsType);return agent.executeTransaction(statements, stringOrNull(params, "schema"));}+ if (AgentProtocol.METHOD_BEGIN_MANUAL_TRANSACTION.equals(method)) {+ return agent.beginManualTransaction(stringOrNull(params, "schema"));+ }+ if (AgentProtocol.METHOD_COMMIT_MANUAL_TRANSACTION.equals(method)) {+ return agent.commitManualTransaction();+ }+ if (AgentProtocol.METHOD_ROLLBACK_MANUAL_TRANSACTION.equals(method)) {+ return agent.rollbackManualTransaction();+ }if (AgentProtocol.METHOD_EXECUTE_BATCH.equals(method)) {Type statementsType = new TypeToken<List<String>>() {}.getType();List<String> statements = gson.fromJson(params.get("statements"), statementsType);@@ -422,6 +433,9 @@ public final class JsonRpcServer {}private boolean requiresSessionAffinity(String method, JsonObject params) {+ if (AgentProtocol.METHOD_BEGIN_MANUAL_TRANSACTION.equals(method)) {+ return true;+ }try {if (AgentProtocol.METHOD_EXECUTE_QUERY.equals(method)|| AgentProtocol.METHOD_EXECUTE_QUERY_PAGE.equals(method)@@ -447,6 +461,23 @@ public final class JsonRpcServer {return false;}+ private static boolean endsSessionAffinity(String method) {+ return AgentProtocol.METHOD_COMMIT_MANUAL_TRANSACTION.equals(method)+ || AgentProtocol.METHOD_ROLLBACK_MANUAL_TRANSACTION.equals(method);+ }++ private boolean preservesSchemaContext() {+ Connection connection = agent.getConnection();+ if (connection == null) {+ return false;+ }+ try {+ return !connection.getAutoCommit();+ } catch (Exception ignored) {+ return false;+ }+ }+private static boolean evictAfterRequest(String method) {return AgentProtocol.METHOD_GET_EXPLAIN_INFO.equals(method);}diff --git a/agents/common/src/test/java/com/dbx/agent/AbstractJdbcAgentTest.java b/agents/common/src/test/java/com/dbx/agent/AbstractJdbcAgentTest.javaindex 54c2708844..09bd975cfd 100644--- a/agents/common/src/test/java/com/dbx/agent/AbstractJdbcAgentTest.java+++ b/agents/common/src/test/java/com/dbx/agent/AbstractJdbcAgentTest.java@@ -300,6 +300,22 @@ class AbstractJdbcAgentTest {);}+ @Test+ void rejectsOneShotTransactionWhenManualTransactionIsOpen() {+ TrackingConnection tracking = new TrackingConnection();+ TestAgent agent = new TestAgent(tracking);+ agent.connect(new ConnectParams());+ agent.beginManualTransaction(null);++ IllegalStateException error = assertThrows(+ IllegalStateException.class,+ () -> agent.executeTransaction(Collections.singletonList("UPDATE A SET ID = 1"), null)+ );++ assertEquals("Cannot start a one-shot transaction while a manual transaction is open", error.getMessage());+ assertEquals(Collections.singletonList("setAutoCommit:false"), tracking.calls);+ }+@Testvoid preservesPlSqlBlockTerminatorDuringTransactionExecution() {TrackingConnection tracking = new TrackingConnection();diff --git a/agents/common/src/test/java/com/dbx/agent/CommonJavaCompatibilityTest.java b/agents/common/src/test/java/com/dbx/agent/CommonJavaCompatibilityTest.javaindex 1af9a28dba..ea9a24058e 100644--- a/agents/common/src/test/java/com/dbx/agent/CommonJavaCompatibilityTest.java+++ b/agents/common/src/test/java/com/dbx/agent/CommonJavaCompatibilityTest.java@@ -150,6 +150,42 @@ class CommonJavaCompatibilityTest {assertEquals("Example JDBC", result.getAsJsonObject("databaseInfo").get("driverName").getAsString());}+ @Test+ void jsonRpcServerDispatchesInteractiveTransactionMethods() {+ List<String> calls = new ArrayList<>();+ MinimalAgent agent = new MinimalAgent() {+ @Override+ public Map<String, Object> beginManualTransaction(String schema) {+ calls.add("begin:" + schema);+ return Collections.singletonMap("ok", (Object) true);+ }++ @Override+ public Map<String, Object> commitManualTransaction() {+ calls.add("commit");+ return Collections.singletonMap("ok", (Object) true);+ }++ @Override+ public Map<String, Object> rollbackManualTransaction() {+ calls.add("rollback");+ return Collections.singletonMap("ok", (Object) true);+ }+ };+ JsonRpcServer server = new JsonRpcServer(agent);++ assertTrue(JsonParser.parseString(server.handleRequest(+ "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"begin_manual_transaction\",\"params\":{\"schema\":\"APP\"}}"+ )).getAsJsonObject().has("result"));+ assertTrue(JsonParser.parseString(server.handleRequest(+ "{\"jsonrpc\":\"2.0\",\"id\":2,\"method\":\"commit_manual_transaction\",\"params\":{}}"+ )).getAsJsonObject().has("result"));+ assertTrue(JsonParser.parseString(server.handleRequest(+ "{\"jsonrpc\":\"2.0\",\"id\":3,\"method\":\"rollback_manual_transaction\",\"params\":{}}"+ )).getAsJsonObject().has("result"));+ assertEquals(List.of("begin:APP", "commit", "rollback"), calls);+ }+@Testvoid multiSessionServerCreatesAndClosesIndependentAgents() throws Exception {java.util.List<TrackingAgent> created = new java.util.ArrayList<>();diff --git a/agents/common/src/test/java/com/dbx/agent/JdbcConnectionPoolingTest.java b/agents/common/src/test/java/com/dbx/agent/JdbcConnectionPoolingTest.javaindex 6a8ccaeeb4..0cd554e285 100644--- a/agents/common/src/test/java/com/dbx/agent/JdbcConnectionPoolingTest.java+++ b/agents/common/src/test/java/com/dbx/agent/JdbcConnectionPoolingTest.java@@ -1869,6 +1869,65 @@ class JdbcConnectionPoolingTest {}}+ @Test+ void interactiveTransactionPinsConnectionUntilCommit() {+ AtomicInteger physicalOpens = new AtomicInteger();+ AtomicInteger requestIds = new AtomicInteger();+ String url = h2Url("manual_transaction");+ try (MultiSessionJsonRpcServer server = server(url, physicalOpens, 2)) {+ openSession(server, requestIds, "transaction");+ query(server, requestIds, "transaction", "CREATE TABLE ITEMS (ID INT)", null);++ result(request(+ server,+ requestIds,+ AgentProtocol.METHOD_BEGIN_MANUAL_TRANSACTION,+ sessionParams("transaction")+ ));+ query(server, requestIds, "transaction", "INSERT INTO ITEMS VALUES (1)", null);++ openSession(server, requestIds, "observer");+ JsonObject beforeCommit = query(server, requestIds, "observer", "SELECT COUNT(*) FROM ITEMS", null);+ assertEquals(0, beforeCommit.getAsJsonArray("rows").get(0).getAsJsonArray().get(0).getAsInt());++ result(request(+ server,+ requestIds,+ AgentProtocol.METHOD_COMMIT_MANUAL_TRANSACTION,+ sessionParams("transaction")+ ));+ JsonObject afterCommit = query(server, requestIds, "observer", "SELECT COUNT(*) FROM ITEMS", null);+ assertEquals(1, afterCommit.getAsJsonArray("rows").get(0).getAsJsonArray().get(0).getAsInt());+ }+ }++ @Test+ void interactiveTransactionRestoresSchemaBeforeReturningConnection() {+ AtomicInteger physicalOpens = new AtomicInteger();+ AtomicInteger requestIds = new AtomicInteger();+ String url = h2Url("manual_transaction_schema");+ try (MultiSessionJsonRpcServer server = server(url, physicalOpens, 2)) {+ openSession(server, requestIds, "transaction-schema");+ query(server, requestIds, "transaction-schema", "CREATE SCHEMA IF NOT EXISTS APP", null);++ JsonObject beginParams = sessionParams("transaction-schema");+ beginParams.addProperty("schema", "APP");+ result(request(server, requestIds, AgentProtocol.METHOD_BEGIN_MANUAL_TRANSACTION, beginParams));+ JsonObject inTransaction = query(server, requestIds, "transaction-schema", "SELECT CURRENT_SCHEMA", null);+ assertEquals("APP", inTransaction.getAsJsonArray("rows").get(0).getAsJsonArray().get(0).getAsString());++ result(request(+ server,+ requestIds,+ AgentProtocol.METHOD_COMMIT_MANUAL_TRANSACTION,+ sessionParams("transaction-schema")+ ));+ openSession(server, requestIds, "schema-observer");+ JsonObject afterCommit = query(server, requestIds, "schema-observer", "SELECT CURRENT_SCHEMA", null);+ assertEquals("PUBLIC", afterCommit.getAsJsonArray("rows").get(0).getAsJsonArray().get(0).getAsString());+ }+ }+@Testvoid affinityDetectionCoversCommonSessionStateStatements() {assertTrue(JdbcConnectionAffinity.requiresSessionAffinity("SET search_path TO app"));diff --git a/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgentTest.java b/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgentTest.javaindex 342f57e9c5..d13f0d5b68 100644--- a/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgentTest.java+++ b/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgentTest.java@@ -150,6 +150,46 @@ class OceanBaseOracleAgentTest {Assertions.assertEquals(List.of(), queryTimeouts);}+ @Test+ void supportsCommitAndRollbackForInteractiveTransactions() {+ List<String> calls = new ArrayList<>();+ OceanBaseOracleAgent agent = new OceanBaseOracleAgent();+ TestSupport.setPrivateConnection(agent, transactionConnection(calls));++ agent.beginManualTransaction(null);+ Assertions.assertEquals(List.of("setAutoCommit:false"), calls);+ agent.commitManualTransaction();+ Assertions.assertEquals(List.of("setAutoCommit:false", "commit", "setAutoCommit:true"), calls);++ agent.beginManualTransaction(null);+ agent.rollbackManualTransaction();+ Assertions.assertEquals(+ List.of("setAutoCommit:false", "commit", "setAutoCommit:true", "setAutoCommit:false", "rollback", "setAutoCommit:true"),+ calls+ );+ }++ @Test+ void failedCommitKeepsTransactionOpenSoItCanBeRolledBack() throws SQLException {+ List<String> calls = new ArrayList<>();+ boolean[] failCommit = {true};+ OceanBaseOracleAgent agent = new OceanBaseOracleAgent();+ Connection connection = transactionConnection(calls, failCommit);+ TestSupport.setPrivateConnection(agent, connection);++ agent.beginManualTransaction(null);+ Assertions.assertThrows(RuntimeException.class, agent::commitManualTransaction);+ Assertions.assertFalse(connection.getAutoCommit());++ failCommit[0] = false;+ Assertions.assertDoesNotThrow(agent::rollbackManualTransaction);+ Assertions.assertTrue(connection.getAutoCommit());+ Assertions.assertEquals(+ List.of("setAutoCommit:false", "commit", "rollback", "setAutoCommit:true"),+ calls+ );+ }+@Testvoid synchronizesSessionTimeoutForEveryQueryEntryPoint() {List<String> sql = new ArrayList<>();@@ -847,6 +887,37 @@ class OceanBaseOracleAgentTest {return executionConnection(sql, new ArrayList<>(), List.of());}+ private static Connection transactionConnection(List<String> calls) {+ return transactionConnection(calls, new boolean[] {false});+ }++ private static Connection transactionConnection(List<String> calls, boolean[] failCommit) {+ boolean[] autoCommit = {true};+ return proxy(Connection.class, (method, args) -> {+ switch (method.getName()) {+ case "getAutoCommit":+ return autoCommit[0];+ case "setAutoCommit":+ autoCommit[0] = (Boolean) args[0];+ calls.add("setAutoCommit:" + autoCommit[0]);+ return null;+ case "commit":+ calls.add("commit");+ if (failCommit[0]) {+ throw new SQLException("commit failed");+ }+ return null;+ case "rollback":+ calls.add("rollback");+ return null;+ case "isClosed":+ return false;+ default:+ return defaultValue(method.getReturnType());+ }+ });+ }+private static Connection executionConnection(List<String> sql,List<Integer> queryTimeouts,diff --git a/apps/desktop/src/components/layout/EditorGroup.vue b/apps/desktop/src/components/layout/EditorGroup.vueindex cf1a166956..f708c36c6a 100644--- a/apps/desktop/src/components/layout/EditorGroup.vue+++ b/apps/desktop/src/components/layout/EditorGroup.vue@@ -13,6 +13,7 @@ import { createContentSurfaceEventForwarders } from "@/lib/tabs/contentSurfaceEvimport { isPreviewTab } from "@/lib/tabs/tabPresentation";import { resolveExecutableSql } from "@/lib/sql/sqlExecutionTarget";import { effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";+import { usesOracleStickyTransactionState } from "@/lib/database/databaseFeatureSupport";import { GROUP_TAB_BAR_PORTAL } from "./groupTabBarPortal";import type { ContentAreaSurfaceEmits, ContentAreaSurfaceProps, QueryEditorSurfaceHandle, StatementRange } from "./querySurfaces";import type { QueryTab } from "@/types/database";@@ -108,7 +109,7 @@ const groupTabs = computed(() => {const activeTab = computed(() => groupTabs.value.find((tab) => tab.id === props.activeTabId) ?? groupTabs.value[0] ?? null);const activeConnection = computed(() => (activeTab.value ? connectionStore.getConfig(activeTab.value.connectionId) : undefined));const showGroupToolbar = computed(() => activeTab.value?.mode === "query" && !isPreviewTab(activeTab.value));-const isGroupOracleManualTransaction = computed(() => effectiveDatabaseTypeForConnection(activeConnection.value) === "oracle" && (activeTab.value?.autoCommit ?? true) === false);+const isGroupOracleManualTransaction = computed(() => usesOracleStickyTransactionState(effectiveDatabaseTypeForConnection(activeConnection.value)) && (activeTab.value?.autoCommit ?? true) === false);// Each group previews the executable SQL of its own active tab (selection// stored on the tab), not the focused tab's global selection.// tabPlacement drives each pane's own bar position: the strip sits above,diff --git a/apps/desktop/src/lib/__tests__/database/databaseFeatureSupport.spec.ts b/apps/desktop/src/lib/__tests__/database/databaseFeatureSupport.spec.tsindex c46b79320a..b173b15c6b 100644--- a/apps/desktop/src/lib/__tests__/database/databaseFeatureSupport.spec.ts+++ b/apps/desktop/src/lib/__tests__/database/databaseFeatureSupport.spec.ts@@ -20,6 +20,7 @@ import {supportsTableImport,supportsTableVacuum,supportsTransaction,+ usesOracleStickyTransactionState,usesConnectionOnlyQueryTarget,usesTreeSchemaMode,schemaNodeHasLoadableName,@@ -160,10 +161,10 @@ describe("supportsTransaction", () => {expect(supportsTransaction("mysql")).toBe(true);expect(supportsTransaction("oracle")).toBe(true);expect(supportsTransaction("jdbc")).toBe(true);+ expect(supportsTransaction("oceanbase-oracle")).toBe(true);});it("returns false for unsupported database types", () => {- expect(supportsTransaction("oceanbase-oracle")).toBe(false);expect(supportsTransaction("redis")).toBe(false);expect(supportsTransaction("mongodb")).toBe(false);expect(supportsTransaction("duckdb")).toBe(false);@@ -198,6 +199,7 @@ describe("defaultAutoCommitForDbType", () => {expect(defaultAutoCommitForDbType("postgres", "manual")).toBe(false);expect(defaultAutoCommitForDbType("oracle", "manual")).toBe(false);expect(defaultAutoCommitForDbType("jdbc", "manual")).toBe(false);+ expect(defaultAutoCommitForDbType("oceanbase-oracle", "manual")).toBe(false);expect(defaultAutoCommitForDbType("mysql", "auto")).toBe(true);expect(defaultAutoCommitForDbType(undefined, "auto")).toBe(true);});@@ -208,11 +210,24 @@ describe("defaultAutoCommitForDbType", () => {expect(defaultAutoCommitForDbType("sqlite", "manual")).toBe(true);expect(defaultAutoCommitForDbType("dameng", "manual")).toBe(true);expect(defaultAutoCommitForDbType("clickhouse", "manual")).toBe(true);- expect(defaultAutoCommitForDbType("oceanbase-oracle", "manual")).toBe(true);expect(defaultAutoCommitForDbType(undefined, "manual")).toBe(true);});});+describe("usesOracleStickyTransactionState", () => {+ it("enables sticky manual-transaction state for Oracle family", () => {+ expect(usesOracleStickyTransactionState("oracle")).toBe(true);+ expect(usesOracleStickyTransactionState("oceanbase-oracle")).toBe(true);+ });++ it("keeps other databases on the generic transaction path", () => {+ expect(usesOracleStickyTransactionState("mysql")).toBe(false);+ expect(usesOracleStickyTransactionState("postgres")).toBe(false);+ expect(usesOracleStickyTransactionState("jdbc")).toBe(false);+ expect(usesOracleStickyTransactionState(undefined)).toBe(false);+ });+});+describe("supportsSqlInListPaste", () => {it("allows generic and SQL-like editors", () => {expect(supportsSqlInListPaste(undefined)).toBe(true);diff --git a/apps/desktop/src/lib/database/databaseFeatureSupport.ts b/apps/desktop/src/lib/database/databaseFeatureSupport.tsindex bb6bdb5a0a..589244d67a 100644--- a/apps/desktop/src/lib/database/databaseFeatureSupport.ts+++ b/apps/desktop/src/lib/database/databaseFeatureSupport.ts@@ -257,7 +257,12 @@ export function usesPostgresLikeStructureCopy(dbType?: DatabaseType): boolean {return !!dbType && PG_LIKE_STRUCTURE_TYPES.has(dbType);}-const TRANSACTION_SUPPORTED_TYPES: readonly string[] = ["postgres", "mysql", "oracle", "jdbc"];+const TRANSACTION_SUPPORTED_TYPES: readonly string[] = ["postgres", "mysql", "oracle", "jdbc", "oceanbase-oracle"];++/** Oracle-family databases that use the sticky manual-transaction UX. OceanBase+ * Oracle mode runs the same transaction model as Oracle, so it shares the+ * commit/rollback dirty-state behavior rather than the generic transaction path. */+const ORACLE_STICKY_TRANSACTION_TYPES: ReadonlySet<string> = new Set(["oracle", "oceanbase-oracle"]);/*** Returns true if the given database type supports explicit transaction control@@ -311,6 +316,14 @@ export function rejectsAliasReferenceInHaving(dbType?: string): boolean {return !!dbType && HAVING_ALIAS_REJECTED_DATABASE_TYPES.has(dbType);}+/**+ * Returns true if the database type uses Oracle's sticky manual-transaction state+ * (commit/rollback hidden until an unproven statement dirties the session).+ */+export function usesOracleStickyTransactionState(dbType?: string): boolean {+ return !!dbType && ORACLE_STICKY_TRANSACTION_TYPES.has(dbType);+}+/*** Default auto-commit mode when opening a query tab for the given database type.* Query tabs default to auto-commit; users can explicitly switch to manual transactions.diff --git a/apps/desktop/src/stores/__tests__/queryStore.manualTransactionExpiry.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.manualTransactionExpiry.spec.tsindex 438aded0b0..fb53764296 100644--- a/apps/desktop/src/stores/__tests__/queryStore.manualTransactionExpiry.spec.ts+++ b/apps/desktop/src/stores/__tests__/queryStore.manualTransactionExpiry.spec.ts@@ -125,12 +125,12 @@ describe("queryStore manual transaction expiry recovery", () => {expect(tab.result?.affected_rows).toBe(1);});- it("normalizes a stale manual OceanBase tab before query dispatch", async () => {+ it("normalizes a stale manual tab for a non-transactional database before query dispatch", async () => {mocks.getConnectionConfig.mockReturnValue({- id: "oceanbase-1",- name: "OceanBase Oracle",- db_type: "oceanbase-oracle",- database: "SYS",+ id: "sqlite-1",+ name: "SQLite",+ db_type: "sqlite",+ database: "main",query_timeout_secs: 30,});mocks.beginManualTransaction.mockRejectedValue(new Error("BEGIN manual transaction failed: Agent RPC error (-1): Unknown method: begin_manual_transaction"));@@ -138,7 +138,7 @@ describe("queryStore manual transaction expiry recovery", () => {const { useQueryStore } = await import("@/stores/queryStore");const store = useQueryStore();- const tabId = store.createTab("oceanbase-1", "SYS", "Query", "query", "SYS");+ const tabId = store.createTab("sqlite-1", "main", "Query", "query", "main");// Simulate a manual-mode value restored from an older saved query tab.store.setAutoCommit(tabId, false);@@ -153,13 +153,20 @@ describe("queryStore manual transaction expiry recovery", () => {expect(tab.result?.execution_error).not.toBe(true);});- it("does not fall back to auto-commit when a supported manual transaction fails to begin", async () => {+ it.each(["oracle", "oceanbase-oracle"] as const)("does not fall back to auto-commit when a supported %s manual transaction fails to begin", async (databaseType) => {mocks.beginManualTransaction.mockRejectedValue(new Error("manual transaction begin failed"));mocks.executeMulti.mockResolvedValue(successfulSelect());+ mocks.getConnectionConfig.mockReturnValue({+ id: `${databaseType}-1`,+ name: databaseType,+ db_type: databaseType,+ database: "ORCL",+ query_timeout_secs: 30,+ });const { useQueryStore } = await import("@/stores/queryStore");const store = useQueryStore();- const tabId = store.createTab("oracle-1", "ORCL", "Query", "query", "APP");+ const tabId = store.createTab(`${databaseType}-1`, "ORCL", "Query", "query", "APP");store.setAutoCommit(tabId, false);await store.executeTabSql(tabId, "SELECT 1 FROM DUAL");@@ -238,20 +245,20 @@ describe("queryStore manual transaction expiry recovery", () => {expect(tab.result?.rows).toEqual([[1]]);});- it("surfaces ordinary query failures after normalizing a stale OceanBase tab", async () => {+ it("surfaces ordinary query failures after normalizing a stale non-transactional tab", async () => {mocks.getConnectionConfig.mockReturnValue({- id: "oceanbase-1",- name: "OceanBase Oracle",- db_type: "oceanbase-oracle",- database: "SYS",+ id: "sqlite-1",+ name: "SQLite",+ db_type: "sqlite",+ database: "main",query_timeout_secs: 30,});mocks.beginManualTransaction.mockRejectedValue(new Error("BEGIN manual transaction failed: Agent RPC error (-1): Unknown method: begin_manual_transaction"));- mocks.executeMulti.mockRejectedValue(new Error("OceanBase query failed"));+ mocks.executeMulti.mockRejectedValue(new Error("SQLite query failed"));const { useQueryStore } = await import("@/stores/queryStore");const store = useQueryStore();- const tabId = store.createTab("oceanbase-1", "SYS", "Query", "query", "SYS");+ const tabId = store.createTab("sqlite-1", "main", "Query", "query", "main");store.setAutoCommit(tabId, false);await store.executeTabSql(tabId, "SELECT missing_column FROM DUAL");diff --git a/apps/desktop/src/stores/__tests__/queryStore.multiStatementError.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.multiStatementError.spec.tsindex 18b6bc6a0d..837f0a14cb 100644--- a/apps/desktop/src/stores/__tests__/queryStore.multiStatementError.spec.ts+++ b/apps/desktop/src/stores/__tests__/queryStore.multiStatementError.spec.ts@@ -558,11 +558,11 @@ describe("queryStore multi-statement errors", () => {expect(tab.results).toHaveLength(4);});- it("invalidates only the executing Oracle tab after successful CURRENT_SCHEMA changes", async () => {+ it.each(["oracle", "oceanbase-oracle"] as const)("invalidates only the executing %s tab after successful CURRENT_SCHEMA changes", async (databaseType) => {mocks.getConnectionConfig.mockReturnValue({- id: "oracle-1",- name: "Oracle",- db_type: "oracle",+ id: `${databaseType}-1`,+ name: databaseType,+ db_type: databaseType,database: "ORCL",query_timeout_secs: 30,});@@ -572,8 +572,8 @@ describe("queryStore multi-statement errors", () => {.mockResolvedValueOnce([{ columns: [], rows: [], affected_rows: 0, execution_time_ms: 1 }]);const { useQueryStore } = await import("@/stores/queryStore");const store = useQueryStore();- const tabA = store.createTab("oracle-1", "ORCL", "Tab A");- const tabB = store.createTab("oracle-1", "ORCL", "Tab B");+ const tabA = store.createTab(`${databaseType}-1`, "ORCL", "Tab A");+ const tabB = store.createTab(`${databaseType}-1`, "ORCL", "Tab B");// Exercise the explicit auto-commit execute-multi path.store.setAutoCommit(tabA, true);store.setAutoCommit(tabB, true);diff --git a/apps/desktop/src/stores/queryStore.ts b/apps/desktop/src/stores/queryStore.tsindex 1d17d89a88..09e8ac479e 100644--- a/apps/desktop/src/stores/queryStore.ts+++ b/apps/desktop/src/stores/queryStore.ts@@ -38,7 +38,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 { defaultAutoCommitForDbType, supportsClearableQuerySchema, supportsTransaction } from "@/lib/database/databaseFeatureSupport";+import { defaultAutoCommitForDbType, supportsClearableQuerySchema, supportsTransaction, usesOracleStickyTransactionState } from "@/lib/database/databaseFeatureSupport";import { canInsertTableRows, canUseKeylessRowPredicate, DBX_ROWID_COLUMN, editablePrimaryKeys, shouldIncludeSyntheticRowId, usesSyntheticRowIdKey } from "@/lib/table/tableEditing";import { TABLE_DATA_EXPORT_PAGE_SIZE } from "@/lib/table/tableDataExport";import { tableMetaForDataTab } from "@/lib/table/tableDataTabMeta";@@ -4578,7 +4578,7 @@ export const useQueryStore = defineStore("query", () => {const tab = tabs.value.find((item) => item.id === id);if (!tab?.txnSessionId) return;const dbType = effectiveDatabaseTypeForConnection(useConnectionStore().getConfig(tab.connectionId));- if (dbType === "oracle") tab.oracleTxnPossiblyDirty = true;+ if (usesOracleStickyTransactionState(dbType)) tab.oracleTxnPossiblyDirty = true;}/** Reset only the Oracle sticky-dirty bit. Used when a session continues but@@ -7009,7 +7009,7 @@ export const useQueryStore = defineStore("query", () => {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 isInitialOracleManualExecution = usesOracleStickyTransactionState(effectiveDbType) && !options?.pagination?.sessionId;const classificationSql = isInitialOracleManualExecution ? queryBaseSql : undefined;let manualTransactionRecoveryAttempted = false;executionPromise = (async () => {@@ -7059,14 +7059,14 @@ export const useQueryStore = defineStore("query", () => {// 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) {+ if (tab.autoCommit === false && usesOracleStickyTransactionState(effectiveDbType) && !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 successfulOracleSchemaChanges = usesOracleStickyTransactionState(effectiveDbType) ? 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;if (hiddenPrimaryKeys.length > 0 && results.length === 1) {@@ -7297,7 +7297,7 @@ export const useQueryStore = defineStore("query", () => {clearOracleTxnPossiblyDirty(tab);tab.txnSessionId = undefined;tab.txnAutoRolledBack = false;- } else if (tab.txnSessionId && executionDispatched && !options?.pagination?.sessionId && effectiveDatabaseTypeForConnection(useConnectionStore().getConfig(tab.connectionId)) === "oracle") {+ } else if (tab.txnSessionId && executionDispatched && !options?.pagination?.sessionId && usesOracleStickyTransactionState(effectiveDatabaseTypeForConnection(useConnectionStore().getConfig(tab.connectionId)))) {// 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 adiff --git a/crates/dbx-core/src/query.rs b/crates/dbx-core/src/query.rsindex 843ffa4f76..00cc80be43 100644--- a/crates/dbx-core/src/query.rs+++ b/crates/dbx-core/src/query.rs@@ -5500,7 +5500,7 @@ pub async fn execute_in_manual_transaction_with_options(empty_query_result(0),options.table_data_preview,);- if db_type == Some(DatabaseType::Oracle) {+ if matches!(db_type, Some(DatabaseType::Oracle | DatabaseType::OceanbaseOracle)) {result = result.with_manual_transaction_no_statement();}return Ok(vec![result]);@@ -5562,11 +5562,12 @@ pub async fn execute_in_manual_transaction_with_options(// 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) {+ let classification: Vec<bool> = if let Some(dialect) =+ db_type.filter(|db_type| matches!(db_type, DatabaseType::Oracle | DatabaseType::OceanbaseOracle))+ {match options.classification_sql.as_deref() {Some(classification_sql) => {- let user_statements =- crate::sql::split_sql_statements_for_database(classification_sql, DatabaseType::Oracle);+ let user_statements = crate::sql::split_sql_statements_for_database(classification_sql, dialect);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()