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(sql): preserve duplicate OceanBase Oracle projections when paging
t8y26d1c3c8373ee
diff --git a/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java b/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.javaindex 078ffaad68..1c212c5e87 100644--- a/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java+++ b/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java@@ -339,6 +339,19 @@ public final class JdbcExecutor {return executePage(conn, sql, schema, setSchemaSql, () -> "", options, valueReader, StatementMessageReader.NONE, tableReadSessions);}+ public QueryPageResult executeBoundedPage(+ Connection conn,+ String sql,+ String schema,+ Function<String, String> setSchemaSql,+ Supplier<String> resetSchemaSql,+ QueryPageOptions options,+ ResultValueReader valueReader+ ) {+ return executePage(conn, sql, schema, setSchemaSql, resetSchemaSql, options, valueReader,+ StatementMessageReader.NONE, sessions, false, true);+ }+public QueryPageResult startTableRead(Connection conn,String sql,@@ -387,6 +400,23 @@ public final class JdbcExecutor {StatementMessageReader statementMessageReader,ConcurrentHashMap<String, QuerySession> targetSessions,boolean advancePastUpdateCounts+ ) {+ return executePage(conn, sql, schema, setSchemaSql, resetSchemaSql, options, valueReader,+ statementMessageReader, targetSessions, advancePastUpdateCounts, false);+ }++ private QueryPageResult executePage(+ Connection conn,+ String sql,+ String schema,+ Function<String, String> setSchemaSql,+ Supplier<String> resetSchemaSql,+ QueryPageOptions options,+ ResultValueReader valueReader,+ StatementMessageReader statementMessageReader,+ ConcurrentHashMap<String, QuerySession> targetSessions,+ boolean advancePastUpdateCounts,+ boolean boundStatementRows) {return unchecked(() -> {expireIdleSessions(targetSessions, System.currentTimeMillis(), QUERY_SESSION_IDLE_TIMEOUT_MILLIS);@@ -402,9 +432,14 @@ public final class JdbcExecutor {QuerySession createdSession = null;activeStatements.add(stmt);try {+ if (boundStatementRows) {+ stmt.setMaxRows(statementMaxRows(options.getMaxRows()));+ }applyQueryTimeout(stmt, options.getTimeoutSecs());if (options.getFetchSize() != null && options.getFetchSize() > 0) {stmt.setFetchSize(options.getFetchSize());+ } else if (boundStatementRows) {+ stmt.setFetchSize(Math.max(1, Math.min(options.getPageSize(), Math.max(options.getMaxRows(), 1))));}// Keep script transaction-control statements in the SQL stream.// JDBC transaction APIs are reserved for executeTransaction.diff --git a/agents/common/src/test/java/com/dbx/agent/JdbcBoundedCursorTest.java b/agents/common/src/test/java/com/dbx/agent/JdbcBoundedCursorTest.javanew file mode 100644index 0000000000..10e6a14607--- /dev/null+++ b/agents/common/src/test/java/com/dbx/agent/JdbcBoundedCursorTest.java@@ -0,0 +1,194 @@+package com.dbx.agent;++import org.junit.jupiter.api.Test;++import java.lang.reflect.InvocationHandler;+import java.lang.reflect.Proxy;+import java.sql.Connection;+import java.sql.ResultSet;+import java.sql.ResultSetMetaData;+import java.sql.SQLException;+import java.sql.Statement;+import java.sql.Types;+import java.util.ArrayList;+import java.util.List;++import static org.junit.jupiter.api.Assertions.*;++class JdbcBoundedCursorTest {+ @Test+ void boundsTheWholeCursorAndPreservesDuplicateColumnsAndLookahead() {+ for (int max : new int[]{0, 1, 3, 10000, Integer.MAX_VALUE}) {+ for (int count : new int[]{0, 1, 2, 3, 4, 5}) {+ Fixture f = new Fixture(count);+ QueryPageResult page = f.start(new QueryPageOptions(1, null, max));+ List<List<Object>> rows = new ArrayList<>(page.getRows());+ while (page.getHas_more()) {+ page = f.executor.fetchPage(page.getSession_id(), 1);+ rows.addAll(page.getRows());+ }+ int expected = Math.min(count, Math.max(max, 1));+ assertEquals(expected, rows.size());+ for (int i = 0; i < expected; i++) assertEquals(List.of(i + 1, i + 1), rows.get(i));+ assertEquals(List.of("NAME", "NAME"), page.getColumns());+ assertEquals(count > expected, page.getTruncated());+ assertEquals(JdbcExecutor.statementMaxRows(max), f.statementLimit);+ assertEquals(1, f.fetchSize);+ f.assertClosed();+ }+ }+ }++ @Test+ void usesPositiveDefaultFetchSizeAndPreservesExplicitFetchSize() {+ for (Integer fetch : new Integer[]{null, 0, -1, 7}) {+ Fixture f = new Fixture(5);+ f.start(new QueryPageOptions(0, fetch, 3));+ assertEquals(fetch != null && fetch > 0 ? fetch : 1, f.fetchSize);+ f.executor.closeAllQuerySessions();+ f.assertClosed();+ }+ Fixture defaults = new Fixture(1);+ defaults.start(new QueryPageOptions());+ assertEquals(10001, defaults.statementLimit);+ assertEquals(100, defaults.fetchSize);+ defaults.assertClosed();+ }++ @Test+ void leavesOrdinaryCursorPolicyUnchanged() {+ Fixture f = new Fixture(5);+ f.executor.executePage(f.connection, "SELECT name, name FROM people", null, schema -> "",+ new QueryPageOptions(1, null, 3));+ assertEquals(0, f.statementLimit);+ assertEquals(0, f.fetchSize);+ f.executor.cancelActiveStatements();+ f.assertClosed();+ }++ @Test+ void cleansUpLimitFetchExecuteAndReadFailures() {+ for (String failure : List.of("setMaxRows", "setFetchSize", "execute", "next")) {+ Fixture f = new Fixture(5);+ f.failure = failure;+ RuntimeException error = assertThrows(RuntimeException.class, () -> f.start(new QueryPageOptions()));+ assertTrue(error.toString().contains("fixture " + failure));+ f.assertClosed();+ }+ Fixture f = new Fixture(5);+ QueryPageResult page = f.start(new QueryPageOptions(1, null, 3));+ f.failure = "next";+ assertThrows(RuntimeException.class, () -> f.executor.fetchPage(page.getSession_id(), 1));+ f.assertClosed();+ }++ @Test+ void cancelsActiveExecutionAndIdleBoundedCursor() {+ Fixture executing = new Fixture(5);+ executing.cancelOnExecute = true;+ assertThrows(RuntimeException.class, () -> executing.start(new QueryPageOptions()));+ assertEquals(1, executing.cancels);+ executing.assertClosed();++ Fixture idle = new Fixture(5);+ idle.start(new QueryPageOptions(1, null, 3));+ idle.executor.cancelActiveStatements();+ assertEquals(1, idle.cancels);+ idle.assertClosed();++ Fixture fetching = new Fixture(5);+ QueryPageResult page = fetching.start(new QueryPageOptions(1, null, 3));+ fetching.cancelOnNext = true;+ assertThrows(RuntimeException.class, () -> fetching.executor.fetchPage(page.getSession_id(), 1));+ assertEquals(1, fetching.cancels);+ fetching.assertClosed();+ }++ private static final class Fixture {+ final JdbcExecutor executor = new JdbcExecutor();+ final int count;+ int row;+ int statementLimit;+ int fetchSize;+ int closes;+ int cancels;+ String failure;+ boolean cancelOnExecute;+ boolean cancelOnNext;+ final ResultSetMetaData metadata = proxy(ResultSetMetaData.class, (object, method, args) -> {+ switch (method.getName()) {+ case "getColumnCount": return 2;+ case "getColumnLabel": return "NAME";+ case "getColumnType": return Types.INTEGER;+ case "getColumnTypeName": return "NUMBER";+ default: return zero(method.getReturnType());+ }+ });+ final ResultSet result = proxy(ResultSet.class, (object, method, args) -> {+ fail(method.getName());+ switch (method.getName()) {+ case "getMetaData": return metadata;+ case "next": return nextRow();+ case "getInt": case "getObject": return row;+ default: return zero(method.getReturnType());+ }+ });+ final Statement statement = proxy(Statement.class, (object, method, args) -> {+ fail(method.getName());+ switch (method.getName()) {+ case "hashCode": return System.identityHashCode(object);+ case "equals": return object == args[0];+ case "setMaxRows": statementLimit = (Integer) args[0]; return null;+ case "setFetchSize": fetchSize = (Integer) args[0]; return null;+ case "execute":+ if (cancelOnExecute) {+ executor.cancelActiveStatements();+ throw new SQLException("fixture canceled");+ }+ return true;+ case "getResultSet": return result;+ case "close": closes++; return null;+ case "cancel": cancels++; return null;+ default: return zero(method.getReturnType());+ }+ });+ final Connection connection = proxy(Connection.class, (object, method, args) ->+ "createStatement".equals(method.getName()) ? statement : zero(method.getReturnType()));++ Fixture(int count) { this.count = count; }++ boolean nextRow() throws SQLException {+ if (cancelOnNext) {+ executor.cancelActiveStatements();+ throw new SQLException("fixture canceled during fetch");+ }+ return ++row <= count && (statementLimit == 0 || row <= statementLimit);+ }++ void fail(String method) throws SQLException {+ if (method.equals(failure)) throw new SQLException("fixture " + method);+ }++ QueryPageResult start(QueryPageOptions options) {+ return executor.executeBoundedPage(connection, "SELECT name, name FROM people", null,+ schema -> "", () -> "", options, executor::defaultResultValue);+ }++ void assertClosed() {+ assertTrue(closes > 0);+ assertFalse(executor.hasActiveStatements());+ assertFalse(executor.hasOpenSessions());+ }+ }++ private static Object zero(Class<?> type) {+ if (type == boolean.class) return false;+ if (type == int.class) return 0;+ if (type == long.class) return 0L;+ return null;+ }++ private static <T> T proxy(Class<T> type, InvocationHandler handler) {+ return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, handler));+ }+}diff --git a/agents/drivers/oceanbase-oracle/src/main/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgent.java b/agents/drivers/oceanbase-oracle/src/main/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgent.javaindex 73f375905c..43596973df 100644--- a/agents/drivers/oceanbase-oracle/src/main/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgent.java+++ b/agents/drivers/oceanbase-oracle/src/main/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgent.java@@ -100,7 +100,13 @@ public final class OceanBaseOracleAgent extends ConfiguredJdbcAgent {@Overridepublic QueryPageResult executeQueryPage(String sql, String schema, QueryPageOptions options) {try (QueryTiming timing = QueryTiming.begin()) {- QueryPageResult result = super.executeQueryPage(sql, schema, options);+ long prepareStarted = System.nanoTime();+ Connection connection = requireConnected();+ uncheckedVoid(() -> beforeQueryExecution(connection, options.getTimeoutSecs()));+ QueryTiming.record("session_prepare", prepareStarted);+ QueryPageResult result = JdbcExecutor.current().executeBoundedPage(+ connection, sql, schema, this::setSchemaSQL, this::resetSchemaSQL, options, resultValueReader()+ );result.setQuery_timings_ms(timing.finish());return result;}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 7e4e22adf1..ffc78b2f80 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@@ -147,7 +147,8 @@ class OceanBaseOracleAgentTest {List<String> auditSql = new ArrayList<>();Connection auditConnection = auditTimingConnection(1, 2, false, auditSql, new ArrayList<>(), auditLimits);int[] row = {-1};- int[] queryLimit = {0}; // JDBC's default, independent of the client-side cap.+ int[] queryLimit = {0};+ int[] queryFetchSize = {0};boolean[] queryStarted = {false};boolean[] resultClosed = {false};boolean[] statementClosed = {false};@@ -167,6 +168,7 @@ class OceanBaseOracleAgentTest {});Statement statement = proxy(Statement.class, (method, args) -> {if ("setMaxRows".equals(method.getName())) queryLimit[0] = (Integer) args[0];+ if ("setFetchSize".equals(method.getName())) queryFetchSize[0] = (Integer) args[0];if ("execute".equals(method.getName())) {queryStarted[0] = !String.valueOf(args[0]).startsWith("ALTER SESSION");statementClosed[0] = false;@@ -198,7 +200,8 @@ class OceanBaseOracleAgentTest {Assertions.assertFalse(result.getHas_more());Assertions.assertEquals(truncated, result.getTruncated());Assertions.assertEquals(truncated ? List.of(List.of(1)) : List.of(List.of(1), List.of(2)), rows);- Assertions.assertEquals(0, queryLimit[0], "the paging cap must not change the JDBC statement limit");+ Assertions.assertEquals(maxRows + 1, queryLimit[0]);+ Assertions.assertTrue(queryFetchSize[0] > 0);Assertions.assertTrue(auditSql.isEmpty(), "completed queries must not read trace or audit records");Assertions.assertTrue(auditLimits.isEmpty());Assertions.assertNull(result.getServer_execute_time_us());diff --git a/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleCursorTransportTest.java b/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleCursorTransportTest.javanew file mode 100644index 0000000000..ee74791823--- /dev/null+++ b/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleCursorTransportTest.java@@ -0,0 +1,78 @@+package com.dbx.agent.oceanbaseoracle;++import com.dbx.agent.JdbcExecutor;+import com.dbx.agent.QueryPageOptions;+import com.oceanbase.jdbc.OceanBaseConnection;+import com.oceanbase.jdbc.UrlParser;+import com.oceanbase.jdbc.internal.com.read.dao.Results;+import com.oceanbase.jdbc.internal.protocol.MasterProtocol;+import com.oceanbase.jdbc.internal.util.pool.GlobalStateInfo;+import org.junit.jupiter.api.Test;++import java.sql.SQLException;+import java.sql.Statement;+import java.util.ArrayList;+import java.util.List;+import java.util.concurrent.locks.ReentrantLock;++import static org.junit.jupiter.api.Assertions.*;++class OceanBaseOracleCursorTransportTest {+ @Test+ void connectorKeepsSqlAndAppliesCumulativeLimitIncludingLookahead() throws Exception {+ for (String sql : List.of("SELECT a.name, a.* FROM people a", "SELECT name, name FROM people",+ "SELECT a.*, b.* FROM people a JOIN people b ON a.id=b.id")) {+ for (int max : new int[]{0, 1, 10000, Integer.MAX_VALUE}) {+ for (boolean fallback : new boolean[]{false, true}) {+ Capture protocol = new Capture(fallback);+ OceanBaseConnection connection = new OceanBaseConnection(protocol);+ JdbcExecutor executor = new JdbcExecutor();+ RuntimeException error = assertThrows(RuntimeException.class, () -> executor.executeBoundedPage(+ connection, sql, null, schema -> "", () -> "", new QueryPageOptions(2, null, max),+ executor::defaultResultValue));+ assertTrue(error.toString().contains("STOP_BEFORE_NETWORK"));+ assertEquals("set @@_ORACLE_SQL_SELECT_LIMIT = " + JdbcExecutor.statementMaxRows(max), protocol.sent.get(0));+ if (fallback) assertEquals("set @@SQL_SELECT_LIMIT = " + JdbcExecutor.statementMaxRows(max), protocol.sent.get(1));+ assertEquals(sql, protocol.sent.get(protocol.sent.size() - 1));+ assertFalse(executor.hasActiveStatements());+ assertFalse(executor.hasOpenSessions());+ protocol.sent.clear();+ try (Statement statement = connection.createStatement()) {+ assertThrows(SQLException.class, () -> statement.execute("SELECT 1 FROM DUAL"));+ }+ assertEquals("set @@_ORACLE_SQL_SELECT_LIMIT = DEFAULT", protocol.sent.get(0));+ if (fallback) assertEquals("set @@SQL_SELECT_LIMIT = DEFAULT", protocol.sent.get(1));+ }+ }+ }+ }++ private static final class Capture extends MasterProtocol {+ final List<String> sent = new ArrayList<>();+ final boolean fallback;++ Capture(boolean fallback) throws Exception {+ super(UrlParser.parse("jdbc:oceanbase://localhost:1/test"), new GlobalStateInfo(), new ReentrantLock(), null);+ this.fallback = fallback;+ connected = true;+ }++ @Override+ public boolean isOracleMode() { return true; }++ @Override+ public boolean versionGreaterOrEqual(int major, int minor, int patch) { return false; }++ @Override+ public void executeQuery(String sql) throws SQLException {+ sent.add(sql);+ if (fallback && sql.contains("_ORACLE_SQL_SELECT_LIMIT")) throw new SQLException("unsupported variable fixture");+ }++ @Override+ public void executeQuery(boolean master, Results results, String sql) throws SQLException {+ sent.add(sql);+ throw new SQLException("STOP_BEFORE_NETWORK", "ZZZZZ");+ }+ }+}diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.tsindex aff6026df9..075dcb2582 100644--- a/apps/desktop/src/lib/backend/tauri.ts+++ b/apps/desktop/src/lib/backend/tauri.ts@@ -539,6 +539,7 @@ export interface QueryPaginationExecutionPlan {exactQueryRowBound?: number;useAgentResultSession: boolean;paginationRowNumberColumn?: string;+ paginationError?: string;}export type QuerySortDirection = "asc" | "desc";diff --git a/apps/desktop/src/stores/__tests__/queryStore.hiddenPrimaryKey.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.hiddenPrimaryKey.spec.tsindex 09249f45e4..7925142ba7 100644--- a/apps/desktop/src/stores/__tests__/queryStore.hiddenPrimaryKey.spec.ts+++ b/apps/desktop/src/stores/__tests__/queryStore.hiddenPrimaryKey.spec.ts@@ -1039,12 +1039,12 @@ describe("queryStore hidden primary key editing", () => {expect(store.tabs.find((tab) => tab.id === tabId)?.result?.large_value_cells).toEqual([{ row_index: 0, column_index: 1, original_bytes: 81920 }]);});- it("continues the Oracle cursor for page 2 in a manual transaction", async () => {- getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });+ it.each(["oracle", "oceanbase-oracle"])("continues the %s cursor for page 2 in a manual transaction", async (databaseType) => {+ getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: databaseType, database: "ORCL", query_timeout_secs: 30 });analyzeEditableQueryEditability.mockResolvedValue({ editable: false, reason: "complex-query" });prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({sqlToExecute: options.sql,- pageSql: options.sql,+ pageSql: databaseType === "oceanbase-oracle" ? undefined : options.sql,pageLimit: options.pagination.limit,pageOffset: options.pagination.offset,countSql: undefined,@@ -2049,6 +2049,94 @@ describe("queryStore hidden primary key editing", () => {);});+ it("advances an OceanBase duplicate projection cursor through an offset jump and next page", async () => {+ getConnectionConfig.mockReturnValue({ id: "ob-1", name: "OceanBase", db_type: "oceanbase-oracle", database: "app", query_timeout_secs: 30 });+ analyzeEditableQueryEditability.mockResolvedValue({ editable: false, reason: "complex-query" });+ prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({+ sqlToExecute: options.sql,+ pageSql: undefined,+ pageLimit: options.pagination.limit,+ pageOffset: options.pagination.offset,+ countSql: undefined,+ useAgentResultSession: true,+ }));+ let row = 0;+ executeMulti.mockImplementation(async () => [+ {+ columns: ["NAME", "NAME"],+ rows: Array.from({ length: 2 }, () => [++row, row]),+ affected_rows: 0,+ execution_time_ms: 1,+ session_id: "ob-cursor",+ has_more: row < 8,+ },+ ]);+ const { useQueryStore } = await import("@/stores/queryStore");+ const store = useQueryStore();+ const tabId = store.createTab("ob-1", "app", "Query");+ const sql = "SELECT a.name, a.* FROM people a ORDER BY a.id";+ await store.executeTabSql(tabId, sql, { pagination: { limit: 2, offset: 4 } });+ const tab = store.tabs.find((item) => item.id === tabId)!;+ expect(tab.result?.rows).toEqual([+ [5, 5],+ [6, 6],+ ]);+ expect(executeMulti).toHaveBeenCalledTimes(3);+ expect(executeMulti.mock.calls[0]![5]).toEqual(expect.objectContaining({ pageSize: 2, fetchSize: 2, resultSessionId: undefined }));+ expect(executeMulti.mock.calls[0]![5].maxRows).toBeGreaterThan(2);+ expect(executeMulti.mock.calls[1]![5].resultSessionId).toBe("ob-cursor");+ await store.executeTabSql(tabId, sql, { pagination: { limit: 2, offset: 6, sessionId: "ob-cursor" } });+ expect(executeMulti).toHaveBeenCalledTimes(4);+ expect(executeMulti.mock.calls[3]![2]).toBe(sql);+ expect(tab.result?.rows).toEqual([+ [7, 7],+ [8, 8],+ ]);+ expect(tab.result?.columns).toEqual(["NAME", "NAME"]);+ });++ it("does not execute an OceanBase offset plan rejected without a cursor", async () => {+ getConnectionConfig.mockReturnValue({ id: "ob-1", name: "OceanBase", db_type: "oceanbase-oracle", database: "app", query_timeout_secs: 30 });+ analyzeEditableQueryEditability.mockResolvedValue({ editable: false, reason: "complex-query" });+ prepareQueryPaginationExecutionPlan.mockImplementation(async () => ({+ sqlToExecute: "",+ pageSql: undefined,+ pageLimit: undefined,+ pageOffset: undefined,+ countSql: undefined,+ useAgentResultSession: false,+ paginationError: "This query requires an Agent result session for offset pagination",+ }));+ const { useQueryStore } = await import("@/stores/queryStore");+ const store = useQueryStore();+ const tabId = store.createTab("ob-1", "app", "Query");+ await store.executeTabSql(tabId, "SELECT name, name FROM people", { pagination: { limit: 2, offset: 4 } });+ expect(JSON.stringify(store.tabs.find((item) => item.id === tabId)?.result)).toContain("requires an Agent result session");+ expect(executeMulti).not.toHaveBeenCalled();+ expect(executeInManualTransaction).not.toHaveBeenCalled();+ });++ it("rejects a fresh OceanBase manual-transaction offset instead of repeating the first page", async () => {+ getConnectionConfig.mockReturnValue({ id: "ob-1", name: "OceanBase", db_type: "oceanbase-oracle", database: "app", query_timeout_secs: 30 });+ analyzeEditableQueryEditability.mockResolvedValue({ editable: false, reason: "complex-query" });+ prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({+ sqlToExecute: options.sql,+ pageSql: undefined,+ pageLimit: options.pagination.limit,+ pageOffset: options.pagination.offset,+ countSql: undefined,+ useAgentResultSession: true,+ }));+ const { useQueryStore } = await import("@/stores/queryStore");+ const store = useQueryStore();+ const tabId = store.createTab("ob-1", "app", "Query");+ store.setAutoCommit(tabId, false);+ await store.executeTabSql(tabId, "SELECT name, name FROM people", { pagination: { limit: 2, offset: 4 } });+ expect(JSON.stringify(store.tabs.find((item) => item.id === tabId)?.result)).toContain("requires an existing result session");+ expect(executeMulti).not.toHaveBeenCalled();+ expect(executeInManualTransaction).not.toHaveBeenCalled();+ });+it("stops appending when a SQL Server query has no bounded next-page plan", async () => {getConnectionConfig.mockReturnValue({ id: "sqlserver-1", name: "SQL Server", db_type: "sqlserver", database: "app", query_timeout_secs: 30 });analyzeEditableQueryEditability.mockResolvedValue({ editable: false, reason: "complex-query" });diff --git a/apps/desktop/src/stores/queryStore.ts b/apps/desktop/src/stores/queryStore.tsindex 8a740b57e3..ac758830d4 100644--- a/apps/desktop/src/stores/queryStore.ts+++ b/apps/desktop/src/stores/queryStore.ts@@ -7710,6 +7710,10 @@ export const useQueryStore = defineStore("query", () => {firstPageUsesActualSql: hiddenPrimaryKeys.length > 0,});const canPaginateSqlServerUseScript = !!sqlServerUseScript && !!plan.pageSql && typeof plan.pageLimit === "number" && typeof plan.pageOffset === "number";+ if (plan.paginationError) throw new Error(plan.paginationError);+ if (effectiveDbType === "oceanbase-oracle" && tab.autoCommit === false && plan.useAgentResultSession && !plan.pageSql && pagination.offset > 0 && !pagination.sessionId) {+ throw new Error("This query requires an existing result session for offset pagination in a manual transaction");+ }if (sqlServerUseScript && !canPaginateSqlServerUseScript) {sqlToExecute = sqlBeforePagination;} else {diff --git a/crates/dbx-core/src/data/query_result_export.rs b/crates/dbx-core/src/data/query_result_export.rsindex b3dacf26c9..c3681f1f3f 100644--- a/crates/dbx-core/src/data/query_result_export.rs+++ b/crates/dbx-core/src/data/query_result_export.rs@@ -999,6 +999,9 @@ async fn export_query_result_core_inner(use_agent_cursor: request.use_agent_cursor,first_page_uses_actual_sql: true,});+ if let Some(error) = plan.pagination_error {+ return Err(error);+ }let Some(plan_limit) = plan.page_limit else {return Err("Failed to build query pagination plan for export".to_string());};@@ -2598,6 +2601,24 @@ mod tests {assert_eq!(streaming_pagination_preflight_error(&req, 100, false, false), None);}+ #[test]+ fn oceanbase_duplicate_projection_export_requires_cursor_and_follows_its_end() {+ let mut req = request("csv", None, None);+ req.database_type = DatabaseType::OceanbaseOracle;+ req.sql = "SELECT a.name, a.* FROM people a ORDER BY a.id".into();+ req.query_base_sql = req.sql.clone();+ req.use_agent_cursor = true;+ assert!(!supports_streaming_offset_pagination(&req, 100));+ assert_eq!(streaming_pagination_preflight_error(&req, 100, false, false), None);+ assert!(should_fetch_next_page(true, true, 100, 100, 100));+ assert!(!should_fetch_next_page(true, false, 100, 100, 100));+ req.use_agent_cursor = false;+ assert_eq!(+ streaming_pagination_preflight_error(&req, 100, false, false),+ Some(STREAMING_PAGINATION_UNSUPPORTED_ERROR)+ );+ }+#[test]fn csv_unlimited_export_has_no_effective_row_limit() {assert_eq!(effective_row_limit(&request("csv", None, None)), None);diff --git a/crates/dbx-sql-data/src/query_result_sql.rs b/crates/dbx-sql-data/src/query_result_sql.rsindex 245126b940..ce8c1f33e4 100644--- a/crates/dbx-sql-data/src/query_result_sql.rs+++ b/crates/dbx-sql-data/src/query_result_sql.rs@@ -63,6 +63,8 @@ pub struct QueryPaginationExecutionPlan {#[serde(skip_serializing_if = "Option::is_none")]pub exact_query_row_bound: Option<usize>,pub use_agent_result_session: bool,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub pagination_error: Option<String>,/// Trailing helper column added by DBX's ROWNUM pagination wrapper.#[serde(default, skip_serializing_if = "Option::is_none")]pub pagination_row_number_column: Option<String>,@@ -152,6 +154,7 @@ pub fn build_query_pagination_execution_plan(count_sql: None,exact_query_row_bound,use_agent_result_session: false,+ pagination_error: None,pagination_row_number_column: None,single_execution: false,};@@ -175,19 +178,21 @@ pub fn build_query_pagination_execution_plan(return plan;}- if sql_server_cte {+ if options.database_type == Some(DatabaseType::OceanbaseOracle)+ && (!rownum_wrapper_projection_is_safe(&options.sql) || has_top_level_rownum(&options.sql))+ {+ if options.use_agent_cursor {+ plan.page_limit = Some(options.pagination.limit.max(1));+ plan.page_offset = Some(options.pagination.offset);+ plan.use_agent_result_session = true;+ } else if options.pagination.offset > 0 {+ plan.pagination_error = Some("This query requires an Agent result session for offset pagination".into());+ plan.sql_to_execute.clear();+ }return plan;}- // Existing top-level ROWNUM predicates/projections cannot be wrapped without- // changing their semantics. Keep one cursor so later pages advance it.- if options.database_type == Some(DatabaseType::OceanbaseOracle)- && options.use_agent_cursor- && has_top_level_rownum(&options.sql)- {- plan.page_limit = Some(options.pagination.limit);- plan.page_offset = Some(options.pagination.offset);- plan.use_agent_result_session = true;+ if sql_server_cte {return plan;}@@ -309,7 +314,14 @@ pub fn build_paginated_query_sql(options: PaginatedQuerySqlOptions) -> QuerySqlBTablePaginationStrategy::Db2FetchFirst | TablePaginationStrategy::FetchFirst => {ok(add_fetch_first_limit(&statement, safe_limit, safe_offset))}- TablePaginationStrategy::Rownum => ok(add_rownum_limit(&statement, safe_limit, safe_offset)),+ TablePaginationStrategy::Rownum => {+ if options.database_type == Some(DatabaseType::OceanbaseOracle)+ && !rownum_wrapper_projection_is_safe(&statement)+ {+ return err("unsupported");+ }+ ok(add_rownum_limit(&statement, safe_limit, safe_offset))+ }TablePaginationStrategy::AgentMaxRows | TablePaginationStrategy::Unbounded => ok(format!("{statement};")),TablePaginationStrategy::IrisTop => ok(add_iris_top_limit(&statement, safe_limit)),TablePaginationStrategy::LimitOffset => {@@ -454,6 +466,29 @@ pub fn build_sorted_query_sql(options: SortedQuerySqlOptions) -> QuerySqlBuildRereturn err("not_select");}+ if options.database_type == Some(DatabaseType::OceanbaseOracle) && !rownum_wrapper_projection_is_safe(statement) {+ let Ok(statements) = Parser::parse_sql(&GenericDialect {}, statement) else {+ return err("unsupported");+ };+ let [Statement::Query(query)] = statements.as_slice() else {+ return err("unsupported");+ };+ if query.limit_clause.is_some()+ || query.fetch.is_some()+ || !query.locks.is_empty()+ || has_top_level_rownum(statement)+ || has_top_level_top(statement)+ || options.column_index >= options.result_columns.len()+ {+ return err("unsupported");+ }+ let end = find_top_level_trailing_order_by(statement).unwrap_or(statement.len());+ return ok(append_sql_suffix(+ statement[..end].trim_end(),+ &format!("ORDER BY {} {};", options.column_index + 1, options.direction.as_sql()),+ ));+ }+let uses_hive_subquery_syntax =matches!(options.database_type, Some(DatabaseType::Argo | DatabaseType::Hive | DatabaseType::Impala));if uses_hive_subquery_syntax {@@ -1908,6 +1943,52 @@ fn add_firebird_rows_limit(statement: &str, limit: usize, offset: usize) -> Striappend_sql_suffix(statement, &format!("{rows};"))}+fn rownum_wrapper_projection_is_safe(statement: &str) -> bool {+ let Ok(statements) = Parser::parse_sql(&GenericDialect {}, statement) else {+ return false;+ };+ let [Statement::Query(query)] = statements.as_slice() else {+ return false;+ };+ fn safe_projection(body: &SetExpr, allow_wildcard: bool) -> bool {+ match body {+ SetExpr::Query(query) => safe_projection(&query.body, allow_wildcard && query.with.is_none()),+ SetExpr::SetOperation { left, .. } => safe_projection(left, allow_wildcard),+ SetExpr::Select(select) => {+ let mut names = HashSet::new();+ select.projection.iter().all(|item| {+ let name = match item {+ SelectItem::ExprWithAlias { alias, .. } => alias,+ SelectItem::UnnamedExpr(Expr::Identifier(name)) => name,+ SelectItem::UnnamedExpr(Expr::CompoundIdentifier(parts)) => {+ let Some(name) = parts.last() else {+ return false;+ };+ name+ }+ SelectItem::Wildcard(_) | SelectItem::QualifiedWildcard(_, _) => {+ return allow_wildcard+ && select.projection.len() == 1+ && select.from.len() == 1+ && select.from[0].joins.is_empty()+ && matches!(&select.from[0].relation, TableFactor::Table { args: None, alias, .. }+ if alias.as_ref().is_none_or(|alias| alias.columns.is_empty()));+ }+ _ => return select.projection.len() == 1,+ };+ names.insert(if name.quote_style.is_some() {+ name.value.clone()+ } else {+ name.value.to_uppercase()+ })+ })+ }+ _ => false,+ }+ }+ safe_projection(&query.body, query.with.is_none())+}+fn add_rownum_limit(statement: &str, limit: usize, offset: usize) -> String {if has_top_level_rownum(statement) {return format!("{statement};");@@ -1915,7 +1996,7 @@ fn add_rownum_limit(statement: &str, limit: usize, offset: usize) -> String {if offset == 0 {return derived_table_sql("SELECT * FROM", statement, &format!("WHERE ROWNUM <= {limit};"));}- let end = offset + limit;+ let end = offset.saturating_add(limit);let column = rownum_pagination_column_name(statement);let inner = derived_table_sql(&format!("SELECT dbx_inner.*, ROWNUM AS \"{column}\" FROM"),@@ -2473,6 +2554,179 @@ fn fallback_alias(index: usize) -> String {#[cfg(test)]mod tests {+ fn oceanbase_plan(sql: &str, limit: usize, offset: usize, cursor: bool) -> QueryPaginationExecutionPlan {+ build_query_pagination_execution_plan(QueryPaginationExecutionPlanOptions {+ sql: sql.into(),+ query_base_sql: sql.into(),+ database_type: Some(DatabaseType::OceanbaseOracle),+ pagination: QueryPagination { limit, offset, session_id: None },+ use_agent_cursor: cursor,+ first_page_uses_actual_sql: true,+ })+ }++ #[test]+ fn oceanbase_cursor_fallback_preserves_limits_and_rejects_unavailable_offsets() {+ for sql in [+ "SELECT a.name, a.* FROM people a ORDER BY a.id",+ "SELECT name, name FROM people WHERE ROWNUM <= 9",+ "SELECT name, name FROM people ORDER BY name FETCH FIRST 9 ROWS ONLY",+ "SELECT * FROM people WHERE ROWNUM <= 9",+ "SELECT * FROM (SELECT name, name FROM people) p",+ "SELECT a.id AS label, a.name AS \"LABEL\" FROM people a",+ "SELECT a.name || a.name, a.name || a.name FROM people a",+ ] {+ for limit in [0, 1, 100, i32::MAX as usize] {+ for offset in [0, 1, 100, 500] {+ let plan = oceanbase_plan(sql, limit, offset, true);+ assert_eq!(plan.sql_to_execute, sql);+ assert!(plan.use_agent_result_session, "{sql}");+ assert_eq!(plan.page_limit, Some(limit.max(1)));+ assert_eq!(plan.page_offset, Some(offset));+ assert!(plan.pagination_error.is_none());+ let plan = oceanbase_plan(sql, limit, offset, false);+ assert!(!plan.use_agent_result_session);+ assert!(plan.page_sql.is_none());+ if offset == 0 {+ assert_eq!(plan.sql_to_execute, sql);+ assert!(plan.pagination_error.is_none());+ } else {+ assert!(plan.pagination_error.is_some());+ assert!(plan.sql_to_execute.is_empty());+ }+ }+ }+ }+ }++ #[test]+ fn oceanbase_safe_projections_keep_bounded_sql_at_every_offset() {+ for sql in [+ "SELECT * FROM people",+ "SELECT a.* FROM people a",+ "SELECT a.id, a.name FROM people a",+ "SELECT a.id AS left_id, b.id AS right_id FROM people a JOIN people b ON a.id=b.id",+ "SELECT a.id AS label, a.name AS \"label\" FROM people a",+ "SELECT name AS label, name AS other_label FROM people ORDER BY name FETCH FIRST 9 ROWS ONLY",+ "SELECT name AS label, COUNT(*) AS n FROM people GROUP BY name",+ ] {+ for cursor in [false, true] {+ for limit in [0, 1, 100, i32::MAX as usize] {+ for offset in [0, 100, 500] {+ let plan = oceanbase_plan(sql, limit, offset, cursor);+ assert!(!plan.use_agent_result_session, "{sql}");+ assert!(plan.pagination_error.is_none());+ assert!(plan.sql_to_execute.contains(sql));+ assert!(plan.sql_to_execute.contains(&format!("ROWNUM <= {}", offset + limit.max(1))));+ assert_eq!(plan.pagination_row_number_column.is_some(), offset > 0);+ }+ }+ }+ }+ }++ #[test]+ fn oceanbase_existing_session_wins_over_projection_and_cursor_availability() {+ let sql = "SELECT a.name, a.* FROM people a";+ let plan = build_query_pagination_execution_plan(QueryPaginationExecutionPlanOptions {+ sql: sql.into(),+ query_base_sql: sql.into(),+ database_type: Some(DatabaseType::OceanbaseOracle),+ pagination: QueryPagination { limit: 10, offset: 50, session_id: Some("cursor".into()) },+ use_agent_cursor: false,+ first_page_uses_actual_sql: false,+ });+ assert!(plan.use_agent_result_session);+ assert_eq!(plan.sql_to_execute, sql);+ assert_eq!(plan.page_offset, Some(50));+ assert!(plan.pagination_error.is_none());+ }++ #[test]+ fn oceanbase_duplicate_projection_sort_preserves_text_and_count_preserves_cardinality() {+ for sql in [+ "SELECT /*+ FULL(a) */ a.name, a.* FROM people a ORDER BY a.id",+ "SELECT DISTINCT name, name FROM people ORDER BY name",+ "SELECT name, name, COUNT(*) FROM people GROUP BY name ORDER BY name",+ "SELECT name, name FROM people UNION ALL SELECT name, name FROM old_people ORDER BY 1",+ ] {+ let sorted = build_sorted_query_sql(SortedQuerySqlOptions {+ original_sql: sql.into(),+ database_type: Some(DatabaseType::OceanbaseOracle),+ result_columns: vec!["NAME".into(), "NAME".into()],+ column_index: 1,+ column: "NAME".into(),+ direction: QuerySortDirection::Desc,+ });+ assert!(sorted.ok, "{sql}");+ let sorted = sorted.sql.unwrap();+ assert_eq!(sorted, format!("{} ORDER BY 2 DESC;", &sql[..sql.rfind(" ORDER BY").unwrap()]));+ assert!(oceanbase_plan(&sorted, 10, 0, true).use_agent_result_session);+ let count = build_count_query_sql(CountQuerySqlOptions {+ original_sql: sql.into(),+ database_type: Some(DatabaseType::OceanbaseOracle),+ });+ assert!(count.ok);+ let count = count.sql.unwrap();+ assert!(count.starts_with("SELECT COUNT(*) AS dbx_total_rows FROM ("));+ assert!(count.contains(sql));+ }+ }++ #[test]+ fn oceanbase_sort_does_not_move_ordering_across_user_limits_or_locks() {+ for suffix in ["WHERE ROWNUM <= 9", "ORDER BY name FETCH FIRST 9 ROWS ONLY", "FOR UPDATE"] {+ let sorted = build_sorted_query_sql(SortedQuerySqlOptions {+ original_sql: format!("SELECT name, name FROM people {suffix}"),+ database_type: Some(DatabaseType::OceanbaseOracle),+ result_columns: vec!["NAME".into(), "NAME".into()],+ column_index: 0,+ column: "NAME".into(),+ direction: QuerySortDirection::Asc,+ });+ assert!(!sorted.ok);+ }+ }++ #[test]+ fn oceanbase_unsafe_projection_uses_cursor_at_every_offset() {+ for sql in [+ "SELECT a.name, a.* FROM people a ORDER BY a.id",+ "SELECT a.name, a.name FROM people a",+ "SELECT a.id, b.id FROM people a JOIN people b ON a.id = b.id",+ "SELECT * FROM people a JOIN people b ON a.id = b.id",+ "SELECT a.*, b.* FROM people a JOIN people b ON a.id = b.id",+ "SELECT a.id AS label, a.name AS LABEL FROM people a",+ "SELECT DISTINCT a.name, a.name FROM people a",+ "SELECT a.name, a.name, COUNT(*) FROM people a GROUP BY a.name",+ "WITH p AS (SELECT * FROM people) SELECT p.name, p.* FROM p",+ "SELECT name, name FROM people UNION ALL SELECT name, name FROM people",+ ] {+ for offset in [0, 100, 500] {+ let plan = super::build_query_pagination_execution_plan(super::QueryPaginationExecutionPlanOptions {+ sql: sql.into(),+ query_base_sql: sql.into(),+ database_type: Some(super::DatabaseType::OceanbaseOracle),+ pagination: super::QueryPagination { limit: 100, offset, session_id: None },+ use_agent_cursor: true,+ first_page_uses_actual_sql: true,+ });+ assert!(plan.use_agent_result_session, "{sql} offset {offset}");+ assert_eq!(plan.sql_to_execute, sql);+ assert_eq!(plan.page_offset, Some(offset));+ assert!(plan.pagination_row_number_column.is_none());+ assert!(plan.page_sql.is_none());+ let rewritten = super::build_paginated_query_sql(super::PaginatedQuerySqlOptions {+ original_sql: sql.into(),+ database_type: Some(super::DatabaseType::OceanbaseOracle),+ limit: 100,+ offset,+ });+ assert!(!rewritten.ok, "{sql}");+ }+ }+ }+use super::*;/// Query shape from issue #7832: a MySQL GROUP BY over a LEFT JOIN with an