Skip to content

armgit / dbx

Public Imported from GitHub
0

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。

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.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<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.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<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.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<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.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<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.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<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) -> 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