diff --git a/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java b/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java index 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 setSchemaSql, + Supplier 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 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 setSchemaSql, + Supplier resetSchemaSql, + QueryPageOptions options, + ResultValueReader valueReader, + StatementMessageReader statementMessageReader, + ConcurrentHashMap 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.java new file mode 100644 index 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> 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 proxy(Class 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.java index 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 { @Override public 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.java index 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 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.java new file mode 100644 index 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 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.ts index 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.ts index 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.ts index 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.rs index 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.rs index 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, pub use_agent_result_session: bool, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub pagination_error: Option, /// Trailing helper column added by DBX's ROWNUM pagination wrapper. #[serde(default, skip_serializing_if = "Option::is_none")] pub pagination_row_number_column: Option, @@ -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) -> QuerySqlB TablePaginationStrategy::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) -> QuerySqlBuildRe return 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) -> Stri append_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