25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(oceanbase-oracle): return dbms output text
efeire13e1823617df
diff --git a/agents/common/src/main/java/com/dbx/agent/AbstractJdbcAgent.java b/agents/common/src/main/java/com/dbx/agent/AbstractJdbcAgent.javaindex e6b64132a9..ccdb74b91e 100644--- a/agents/common/src/main/java/com/dbx/agent/AbstractJdbcAgent.java+++ b/agents/common/src/main/java/com/dbx/agent/AbstractJdbcAgent.java@@ -202,7 +202,7 @@ public abstract class AbstractJdbcAgent extends BaseDatabaseAgent {options.getFetchSize(),options.getTimeoutSecs(),resultValueReader(),- JdbcExecutor.StatementMessageReader.NONE,+ statementMessageReader(),advancePastUpdateCounts());}@@ -221,6 +221,7 @@ public abstract class AbstractJdbcAgent extends BaseDatabaseAgent {this::resetSchemaSQL,options,resultValueReader(),+ statementMessageReader(),advancePastUpdateCounts());}@@ -602,6 +603,10 @@ public abstract class AbstractJdbcAgent extends BaseDatabaseAgent {protected void beforeQueryExecution(Connection connection, int timeoutSecs) throws Exception {}+ protected JdbcExecutor.StatementMessageReader statementMessageReader() {+ return JdbcExecutor.StatementMessageReader.NONE;+ }+/** Called for each session RPC before its SQL can replace the connection's last trace ID. */protected void beforeAgentMethod(String method, String querySessionId) {}diff --git a/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java b/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.javaindex dfb75839bd..31345d7231 100644--- a/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java+++ b/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java@@ -15,6 +15,7 @@ import java.util.Collections;import java.util.IdentityHashMap;import java.util.List;import java.util.Locale;+import java.util.Map;import java.util.Set;import java.util.UUID;import java.util.concurrent.ConcurrentHashMap;@@ -300,6 +301,7 @@ public final class JdbcExecutor {try (ResultSet rs = stmt.getResultSet()) {result = readResultSet(rs, elapsed, effectiveMaxRows, valueReader);}+ appendStatementReaderMessages(result, stmt, statementMessageReader);// `elapsed` stops at `stmt.execute()`. Retrieving and// converting the rows above is frequently the dominant// cost of a statement, so report the whole duration the@@ -316,7 +318,9 @@ public final class JdbcExecutor {false);}- return withStatementMessages(result, stmt, effectiveMaxRows, statementMessageReader);+ QueryResult completed = withStatementMessages(result, stmt, effectiveMaxRows, statementMessageReader);+ completed.setExecution_time_ms(System.currentTimeMillis() - start);+ return completed;} finally {activeStatements.remove(stmt);}@@ -411,6 +415,21 @@ public final class JdbcExecutor {return executePage(conn, sql, schema, setSchemaSql, () -> "", options, valueReader, statementMessageReader, sessions);}+ public QueryPageResult executePage(+ Connection conn,+ String sql,+ String schema,+ Function<String, String> setSchemaSql,+ Supplier<String> resetSchemaSql,+ QueryPageOptions options,+ ResultValueReader valueReader,+ StatementMessageReader statementMessageReader,+ boolean advancePastUpdateCounts+ ) {+ return executePage(conn, sql, schema, setSchemaSql, resetSchemaSql, options, valueReader,+ statementMessageReader, sessions, advancePastUpdateCounts);+ }+public QueryPageResult executePage(Connection conn,String sql,@@ -471,6 +490,20 @@ public final class JdbcExecutor {StatementMessageReader.NONE, sessions, false, true);}+ public QueryPageResult executeBoundedPage(+ Connection conn,+ String sql,+ String schema,+ Function<String, String> setSchemaSql,+ Supplier<String> resetSchemaSql,+ QueryPageOptions options,+ ResultValueReader valueReader,+ StatementMessageReader statementMessageReader+ ) {+ return executePage(conn, sql, schema, setSchemaSql, resetSchemaSql, options, valueReader,+ statementMessageReader, sessions, false, true);+ }+public QueryPageResult startTableRead(Connection conn,String sql,@@ -600,6 +633,7 @@ public final class JdbcExecutor {} else {appendStatementWarnings(result, stmt);}+ result.setExecution_time_ms(System.currentTimeMillis() - start);activeStatements.remove(stmt);stmt.close();QueryPageResult page = new QueryPageResult(@@ -642,7 +676,8 @@ public final class JdbcExecutor {sqlTypeByIndex,typeNameByIndex,Math.max(options.getMaxRows(), 1),- valueReader+ valueReader,+ statementMessageReader);createdSession = session;targetSessions.put(sessionId, session);@@ -939,7 +974,7 @@ public final class JdbcExecutor {while (rows.size() < effectivePageSize && session.rowsRead < session.maxRows) {if (!session.resultSet.next()) {QueryPageResult page = sessionPageResult(session, rows, executionTimeMs, false, null, false);- closeSession(targetSessions, session.id);+ appendStatementReaderMessages(page, closeSessionMessages(targetSessions, session.id));return page;}rows.add(rowValues(session.resultSet, session.valueReader, session.sqlTypeByIndex, session.typeNameByIndex));@@ -949,14 +984,14 @@ public final class JdbcExecutor {if (session.rowsRead >= session.maxRows) {boolean truncated = session.resultSet.next();QueryPageResult page = sessionPageResult(session, rows, executionTimeMs, truncated, null, false);- closeSession(targetSessions, session.id);+ appendStatementReaderMessages(page, closeSessionMessages(targetSessions, session.id));return page;}boolean hasMore = session.resultSet.next();if (!hasMore) {QueryPageResult page = sessionPageResult(session, rows, executionTimeMs, false, null, false);- closeSession(targetSessions, session.id);+ appendStatementReaderMessages(page, closeSessionMessages(targetSessions, session.id));return page;}@@ -990,9 +1025,13 @@ public final class JdbcExecutor {}private boolean closeSession(ConcurrentHashMap<String, QuerySession> targetSessions, String sessionId) {+ return closeSessionMessages(targetSessions, sessionId) != null;+ }++ private List<String> closeSessionMessages(ConcurrentHashMap<String, QuerySession> targetSessions, String sessionId) {QuerySession session = targetSessions.remove(sessionId);if (session == null) {- return false;+ return null;}synchronized (session) {activeStatements.remove(session.statement);@@ -1000,12 +1039,17 @@ public final class JdbcExecutor {session.resultSet.close();} catch (Exception ignored) {}+ List<String> messages = Collections.emptyList();+ try {+ messages = session.statementMessageReader.close(session.statement);+ } catch (Exception ignored) {+ }try {session.statement.close();} catch (Exception ignored) {}+ return messages == null ? Collections.emptyList() : messages;}- return true;}static String safeColumnTypeName(ResultSetMetaData meta, int columnIndex) {@@ -1144,6 +1188,32 @@ public final class JdbcExecutor {return messageResult;}+ private static void appendStatementReaderMessages(+ QueryResult result,+ Statement statement,+ StatementMessageReader reader+ ) {+ try {+ List<String> messages = reader.close(statement);+ if (messages != null) {+ for (String message : messages) {+ if (message != null) result.addInformationalMessage(message, null);+ }+ }+ } catch (Exception ignored) {+ // Driver-specific informational output is advisory.+ }+ }++ private static void appendStatementReaderMessages(QueryPageResult page, List<String> messages) {+ if (messages == null || messages.isEmpty()) return;+ List<Map<String, Object>> result = new ArrayList<>(page.getMessages());+ for (String message : messages) {+ if (message != null) result.add(Map.of("severity", "INFO", "message", message));+ }+ page.setMessages(result);+ }+private QueryResult emptyQueryResult(long start) {return new QueryResult(Collections.emptyList(),@@ -1217,6 +1287,10 @@ public final class JdbcExecutor {StatementMessageReader NONE = statement -> Collections.emptyList();List<String> read(Statement statement) throws SQLException;++ default List<String> close(Statement statement) throws SQLException {+ return Collections.emptyList();+ }}/**@@ -1262,6 +1336,7 @@ public final class JdbcExecutor {private final String[] typeNameByIndex;private final int maxRows;private final ResultValueReader valueReader;+ private final StatementMessageReader statementMessageReader;private int rowsRead;private List<Object> pendingRow;private long lastAccessedAtMillis;@@ -1275,7 +1350,8 @@ public final class JdbcExecutor {int[] sqlTypeByIndex,String[] typeNameByIndex,int maxRows,- ResultValueReader valueReader+ ResultValueReader valueReader,+ StatementMessageReader statementMessageReader) {this.id = id;this.statement = statement;@@ -1286,6 +1362,7 @@ public final class JdbcExecutor {this.typeNameByIndex = typeNameByIndex;this.maxRows = maxRows;this.valueReader = valueReader;+ this.statementMessageReader = statementMessageReader;this.lastAccessedAtMillis = System.currentTimeMillis();}}diff --git a/agents/common/src/test/java/com/dbx/agent/JdbcExecutorTest.java b/agents/common/src/test/java/com/dbx/agent/JdbcExecutorTest.javaindex 8ff05ac81b..79024d3d69 100644--- a/agents/common/src/test/java/com/dbx/agent/JdbcExecutorTest.java+++ b/agents/common/src/test/java/com/dbx/agent/JdbcExecutorTest.java@@ -203,6 +203,39 @@ class JdbcExecutorTest {);}+ @Test+ void executeCountsDriverMessageReadingInExecutionTime() {+ JdbcExecutor.StatementMessageReader reader = statement -> {+ try {+ Thread.sleep(30L);+ } catch (InterruptedException error) {+ Thread.currentThread().interrupt();+ throw new SQLException(error);+ }+ return Collections.singletonList("procedure output");+ };++ QueryResult result = JdbcExecutor.INSTANCE.execute(+ executionConnection(false, -1, null, new AtomicInteger(), null, null),+ "BEGIN OUTPUT_TEXT(); END;", "", schema -> "", () -> "", 100, null, 0,+ JdbcExecutor.INSTANCE::defaultResultValue, reader+ );++ assertTrue(result.getExecution_time_ms() >= 25L,+ "driver message reading must count toward execution_time_ms but was " + result.getExecution_time_ms() + "ms");+ for (boolean bounded : List.of(false, true)) {+ Connection connection = executionConnection(false, -1, null, new AtomicInteger(), null, null);+ QueryPageResult page = bounded+ ? JdbcExecutor.INSTANCE.executeBoundedPage(connection, "BEGIN OUTPUT_TEXT(); END;", "",+ schema -> "", () -> "", new QueryPageOptions(), JdbcExecutor.INSTANCE::defaultResultValue, reader)+ : JdbcExecutor.INSTANCE.executePage(connection, "BEGIN OUTPUT_TEXT(); END;", "",+ schema -> "", () -> "", new QueryPageOptions(), JdbcExecutor.INSTANCE::defaultResultValue, reader, false);+ assertEquals(List.of(List.of("procedure output")), page.getRows());+ assertTrue(page.getExecution_time_ms() >= 25L,+ "paged message reading must count toward execution_time_ms but was " + page.getExecution_time_ms() + "ms");+ }+ }+@Testvoid executeReturnsMultipleStatementWarningsForNoResultStatements() {SQLWarning first = new SQLWarning("identity value is 443", "S0003", 7998);@@ -336,6 +369,42 @@ class JdbcExecutorTest {assertEquals("informational", result.getMessages().get(0).get("message"));}+ @Test+ void executeRetainsRowsAndAddsDriverMessagesWhenResultSetCompletes() {+ CountingResultSetFixture fixture = countingResultSet(new Object[][]{{1, "Ada"}});+ boolean[] closed = {false};+ JdbcExecutor.StatementMessageReader reader = new JdbcExecutor.StatementMessageReader() {+ @Override+ public List<String> read(Statement statement) {+ return Collections.emptyList();+ }++ @Override+ public List<String> close(Statement statement) {+ closed[0] = true;+ return Arrays.asList("procedure output");+ }+ };++ QueryResult result = JdbcExecutor.INSTANCE.execute(+ executionConnection(true, -1, null, new AtomicInteger(), fixture.resultSet(), null),+ "BEGIN OPEN_RESULT(); END;",+ "",+ schema -> "",+ () -> "",+ 100,+ null,+ 0,+ JdbcExecutor.INSTANCE::defaultResultValue,+ reader+ );++ assertTrue(closed[0]);+ assertEquals(Arrays.asList("id", "name"), result.getColumns());+ assertEquals(Arrays.asList(Arrays.asList(1, "Ada")), result.getRows());+ assertEquals("procedure output", result.getMessages().get(0).get("message"));+ }+@Testvoid executePageRetainsWarningsWithOrdinaryRows() {CountingResultSetFixture fixture = countingResultSet(new Object[][]{{1, "Ada"}});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 d3be303534..5dd092897d 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@@ -35,10 +35,13 @@ import com.dbx.agent.SpatialColumn;import com.dbx.agent.TableInfo;import com.dbx.agent.TriggerInfo;+import java.sql.CallableStatement;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;+import java.sql.SQLTimeoutException;+import java.sql.Statement;import java.sql.Types;import java.util.ArrayDeque;import java.util.ArrayList;@@ -73,6 +76,9 @@ public final class OceanBaseOracleAgent extends ConfiguredJdbcAgent {private boolean queryTimeoutChanged;private final OceanBaseLobValues lobValues = new OceanBaseLobValues();private boolean deferCharacterLobs;+ private boolean captureDbmsOutput;+ private boolean dbmsOutputEnabled;+ private String dbmsOutputWarning;public static final JdbcAgentProfile OCEANBASE_ORACLE_PROFILE = new JdbcAgentProfile("com.oceanbase.jdbc.Driver",@@ -108,8 +114,11 @@ public final class OceanBaseOracleAgent extends ConfiguredJdbcAgent {@Overridepublic QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {var lobCheckpoint = lobValues.checkpoint();+ Connection outputConnection = null;try (QueryTiming timing = QueryTiming.begin()) {prepareLobExecution(sql, options.getDeferLobs());+ captureDbmsOutput = isDbmsOutputStatement(sql);+ outputConnection = requireConnected();QueryResult result = super.executeQuery(sql, schema, options);var marked = OceanBaseLobValues.mark(result.getColumns(), result.getColumn_types(), result.getRows());if (marked != null) {@@ -124,9 +133,13 @@ public final class OceanBaseOracleAgent extends ConfiguredJdbcAgent {result.setQuery_timings_ms(timing.finish());return result;} catch (RuntimeException error) {+ if (dbmsOutputEnabled && outputConnection != null) cleanupDbmsOutputAfterFailure(outputConnection, error);lobValues.releaseSince(lobCheckpoint);throw error;} finally {+ captureDbmsOutput = false;+ dbmsOutputEnabled = false;+ dbmsOutputWarning = null;deferCharacterLobs = false;}}@@ -134,22 +147,29 @@ public final class OceanBaseOracleAgent extends ConfiguredJdbcAgent {@Overridepublic QueryPageResult executeQueryPage(String sql, String schema, QueryPageOptions options) {var lobCheckpoint = lobValues.checkpoint();+ Connection outputConnection = null;try (QueryTiming timing = QueryTiming.begin()) {prepareLobExecution(sql, options.getDeferLobs());+ captureDbmsOutput = isDbmsOutputStatement(sql);long prepareStarted = System.nanoTime();- Connection connection = requireConnected();+ outputConnection = requireConnected();+ Connection connection = outputConnection;uncheckedVoid(() -> beforeQueryExecution(connection, options.getTimeoutSecs()));QueryTiming.record("session_prepare", prepareStarted);QueryPageResult result = JdbcExecutor.current().executeBoundedPage(- connection, sql, schema, this::setSchemaSQL, this::resetSchemaSQL, options, resultValueReader()+ connection, sql, schema, this::setSchemaSQL, this::resetSchemaSQL, options, resultValueReader(), statementMessageReader());markLobPage(result);result.setQuery_timings_ms(timing.finish());return result;} catch (RuntimeException error) {+ if (dbmsOutputEnabled && outputConnection != null) cleanupDbmsOutputAfterFailure(outputConnection, error);lobValues.releaseSince(lobCheckpoint);throw error;} finally {+ captureDbmsOutput = false;+ dbmsOutputEnabled = false;+ dbmsOutputWarning = null;deferCharacterLobs = false;}}@@ -342,13 +362,173 @@ public final class OceanBaseOracleAgent extends ConfiguredJdbcAgent {try (var stmt = connection.createStatement()) {try {stmt.execute(queryTimeoutSql(timeoutSecs));+ queryTimeoutChanged = true;} catch (SQLException error) {- if (isReadOnlyTransactionError(error)) {- return;+ if (!isReadOnlyTransactionError(error)) throw error;+ }+ }+ dbmsOutputEnabled = captureDbmsOutput;+ dbmsOutputWarning = captureDbmsOutput ? enableDbmsOutput(connection) : null;+ }++ @Override+ protected JdbcExecutor.StatementMessageReader statementMessageReader() {+ if (!captureDbmsOutput) return JdbcExecutor.StatementMessageReader.NONE;+ String setupWarning = dbmsOutputWarning;+ boolean outputEnabled = dbmsOutputEnabled;+ return new JdbcExecutor.StatementMessageReader() {+ private boolean cleaned;++ @Override+ public List<String> read(Statement statement) throws SQLException {+ List<String> lines = new ArrayList<>();+ if (!outputEnabled) {+ if (setupWarning != null) lines.add(setupWarning);+ return lines;+ }+ int characters = 0;+ boolean truncated = false;+ try (CallableStatement call = statement.getConnection().prepareCall("{call DBMS_OUTPUT.GET_LINE(?, ?)}")) {+ call.setQueryTimeout(2);+ call.registerOutParameter(1, Types.VARCHAR);+ call.registerOutParameter(2, Types.INTEGER);+ long deadline = System.nanoTime() + 5_000_000_000L;+ while (lines.size() < 256 && characters < 65_536) {+ if (System.nanoTime() >= deadline) {+ lines.add("DBMS_OUTPUT truncated after 5 seconds");+ truncated = true;+ break;+ }+ call.execute();+ if (call.getInt(2) != 0) break;+ String line = call.getString(1);+ if (line == null) line = "";+ int remaining = 65_536 - characters;+ if (line.length() > remaining) {+ int end = remaining;+ if (end > 0 && Character.isHighSurrogate(line.charAt(end - 1))+ && Character.isLowSurrogate(line.charAt(end))) {+ end--;+ }+ lines.add(line.substring(0, end));+ lines.add("DBMS_OUTPUT truncated at 65536 characters");+ truncated = true;+ break;+ }+ lines.add(line);+ characters += line.length();+ }+ if (!truncated && (lines.size() == 256 || characters >= 65_536)) {+ if (System.nanoTime() >= deadline) {+ lines.add("DBMS_OUTPUT truncated after 5 seconds");+ } else {+ call.execute();+ if (call.getInt(2) == 0) lines.add("DBMS_OUTPUT truncated at the output limit");+ }+ }+ } catch (SQLException ignored) {+ lines.add("DBMS_OUTPUT could not be read after statement execution");+ } finally {+ cleanup(statement, lines);+ }+ return lines;+ }++ @Override+ public List<String> close(Statement statement) throws SQLException {+ if (!outputEnabled) return setupWarning == null ? List.of() : List.of(setupWarning);+ return read(statement);+ }++ private void cleanup(Statement statement, List<String> messages) throws SQLException {+ if (cleaned) return;+ cleaned = true;+ appendDbmsOutputCleanupWarning(statement.getConnection(), messages);+ }+ };+ }++ private static boolean isDbmsOutputStatement(String sql) {+ if (sql == null) return false;+ String leading = sql.replaceFirst("(?s)^(?:\\s|--[^\\r\\n]*(?:\\r?\\n|$)|/\\*.*?\\*/)*", "");+ return leading.matches("(?is)^(?:<<\\s*[\\p{L}_][\\p{L}\\p{N}_$#]*\\s*>>\\s*)?(?:BEGIN|DECLARE|CALL|EXEC|EXECUTE)\\b.*")+ || leading.matches("(?is)^\\{\\s*(?:\\?\\s*=\\s*)?CALL\\b.*\\}");+ }++ private String enableDbmsOutput(Connection connection) {+ try (var statement = connection.createStatement()) {+ statement.setQueryTimeout(2);+ statement.execute("BEGIN DBMS_OUTPUT.DISABLE; DBMS_OUTPUT.ENABLE(NULL); END;");+ return null;+ } catch (SQLException error) {+ if (error instanceof SQLTimeoutException || hasConnectionFailure(error)) {+ try {+ discardConnection(connection);+ } catch (SQLException discardError) {+ error.addSuppressed(discardError);}- throw error;+ captureDbmsOutput = false;+ dbmsOutputEnabled = false;+ throw new RuntimeException("DBMS_OUTPUT setup failed; the connection was discarded", error);+ }+ if (isExpectedDbmsOutputUnavailable(error)) {+ dbmsOutputEnabled = false;+ return "DBMS_OUTPUT could not be enabled; statement execution continued";+ }+ throw new RuntimeException("DBMS_OUTPUT setup failed", error);+ }+ }++ private static boolean hasConnectionFailure(SQLException error) {+ for (SQLException current = error; current != null; current = current.getNextException()) {+ String state = current.getSQLState();+ if (state != null && state.startsWith("08")) return true;+ }+ return false;+ }++ private static boolean isExpectedDbmsOutputUnavailable(SQLException error) {+ for (SQLException current = error; current != null; current = current.getNextException()) {+ int code = Math.abs(current.getErrorCode());+ String message = current.getMessage();+ String lower = message == null ? "" : message.toLowerCase(Locale.ROOT);+ if (code == 1031 || code == 5543 || code == 5546 || lower.contains("insufficient privilege")+ || (lower.contains("not declared") || lower.contains("must be declared")) && lower.contains("dbms_output")+ || lower.contains("dbms_output") && (lower.contains("not supported") || lower.contains("does not exist"))) {+ return true;+ }+ }+ return false;+ }++ private void appendDbmsOutputCleanupWarning(Connection connection, List<String> messages) {+ try (var statement = connection.createStatement()) {+ statement.setQueryTimeout(2);+ statement.execute("BEGIN DBMS_OUTPUT.DISABLE; END;");+ } catch (SQLException cleanupError) {+ try {+ discardConnection(connection);+ messages.add("DBMS_OUTPUT cleanup failed; the connection was discarded");+ } catch (SQLException discardError) {+ cleanupError.addSuppressed(discardError);+ messages.add("DBMS_OUTPUT cleanup and connection disposal failed");+ }+ }+ }++ private void cleanupDbmsOutputAfterFailure(Connection connection, RuntimeException error) {+ try {+ try (var statement = connection.createStatement()) {+ statement.setQueryTimeout(2);+ statement.execute("BEGIN DBMS_OUTPUT.DISABLE; END;");+ }+ } catch (SQLException cleanupError) {+ error.addSuppressed(cleanupError);+ try {+ discardConnection(connection);+ } catch (SQLException discardError) {+ error.addSuppressed(discardError);}- queryTimeoutChanged = true;}}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 405e7c6274..45b0915d7c 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@@ -22,22 +22,404 @@ import org.junit.jupiter.params.ParameterizedTest;import org.junit.jupiter.params.provider.CsvSource;import java.lang.reflect.InvocationHandler;+import java.lang.reflect.Field;import java.lang.reflect.Method;import java.lang.reflect.Proxy;+import java.sql.CallableStatement;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.ResultSetMetaData;import java.sql.SQLException;import java.sql.SQLFeatureNotSupportedException;+import java.sql.SQLTimeoutException;import java.sql.Statement;import java.sql.Types;import java.util.ArrayList;import java.util.Arrays;import java.util.List;import java.util.Locale;+import java.util.concurrent.atomic.AtomicInteger;class OceanBaseOracleAgentTest {+ @Test+ void returnsDbmsOutputThroughRegularAndBoundedExecutionPaths() throws Exception {+ assertDbmsOutputExecution(false);+ }++ @Test+ void returnsDbmsOutputWhenSessionTimeoutIsRejectedAsReadOnly() throws Exception {+ assertDbmsOutputExecution(true);+ }++ private void assertDbmsOutputExecution(boolean readOnlyTimeout) throws Exception {+ String block = "BEGIN DBMS_OUTPUT.PUT_LINE('hello world'); END;";+ for (boolean paged : List.of(false, true)) {+ AtomicInteger prepareCalls = new AtomicInteger();+ AtomicInteger getLineCalls = new AtomicInteger();+ List<String> executedSql = new ArrayList<>();+ Connection[] connectionRef = new Connection[1];+ CallableStatement output = proxy(CallableStatement.class, (method, args) -> {+ if ("execute".equals(method.getName())) {+ getLineCalls.incrementAndGet();+ return false;+ }+ if ("getInt".equals(method.getName())) return getLineCalls.get() == 1 ? 0 : 1;+ if ("getString".equals(method.getName())) return "hello world";+ return defaultValue(method.getReturnType());+ });+ Statement statement = proxy(Statement.class, (method, args) -> {+ if ("execute".equals(method.getName())) {+ executedSql.add(String.valueOf(args[0]));+ if (readOnlyTimeout && String.valueOf(args[0]).startsWith("ALTER SESSION SET ob_query_timeout")) {+ throw new SQLException("read only", "25006");+ }+ return false;+ }+ if ("getConnection".equals(method.getName())) return connectionRef[0];+ if ("getUpdateCount".equals(method.getName())) return -1;+ if ("getWarnings".equals(method.getName())) return null;+ return defaultValue(method.getReturnType());+ });+ Connection connection = proxy(Connection.class, (method, args) -> {+ if ("createStatement".equals(method.getName())) return statement;+ if ("prepareCall".equals(method.getName())) {+ prepareCalls.incrementAndGet();+ return output;+ }+ return defaultValue(method.getReturnType());+ });+ connectionRef[0] = connection;+ OceanBaseOracleAgent agent = new OceanBaseOracleAgent();+ TestSupport.setPrivateConnection(agent, connection);++ List<String> columns;+ List<List<Object>> rows;+ if (paged) {+ QueryPageResult result = agent.executeQueryPage(block, null, new QueryPageOptions());+ columns = result.getColumns();+ rows = result.getRows();+ } else {+ QueryResult result = agent.executeQuery(block, null, new ExecuteQueryOptions());+ columns = result.getColumns();+ rows = result.getRows();+ }++ Assertions.assertEquals(List.of("Message"), columns);+ Assertions.assertEquals(List.of(List.of("hello world")), rows);+ Assertions.assertEquals(1, prepareCalls.get());+ Assertions.assertEquals(2, getLineCalls.get());+ Assertions.assertEquals(1, executedSql.stream().filter(block::equals).count());+ Assertions.assertTrue(executedSql.contains("BEGIN DBMS_OUTPUT.DISABLE; DBMS_OUTPUT.ENABLE(NULL); END;"));+ Assertions.assertTrue(executedSql.indexOf("BEGIN DBMS_OUTPUT.DISABLE; DBMS_OUTPUT.ENABLE(NULL); END;")+ > executedSql.indexOf("ALTER SESSION SET ob_query_timeout"));+ Assertions.assertEquals("BEGIN DBMS_OUTPUT.DISABLE; END;", executedSql.get(executedSql.size() - 1));++ if (paged) {+ agent.executeQueryPage("SELECT 1 FROM DUAL", null, new QueryPageOptions());+ } else {+ agent.executeQuery("SELECT 1 FROM DUAL", null, new ExecuteQueryOptions());+ }+ Assertions.assertEquals(1, prepareCalls.get(), "ordinary SQL must not read DBMS_OUTPUT");+ }+ }++ @Test+ void doesNotInstallDbmsOutputReaderForOrdinaryStatements() throws Exception {+ OceanBaseOracleAgent agent = new OceanBaseOracleAgent();+ Method readerMethod = OceanBaseOracleAgent.class.getDeclaredMethod("statementMessageReader");+ readerMethod.setAccessible(true);++ Assertions.assertSame(+ com.dbx.agent.JdbcExecutor.StatementMessageReader.NONE,+ readerMethod.invoke(agent)+ );+ }++ @Test+ void recognizesLabeledAnonymousBlocksForDbmsOutput() throws Exception {+ Method classify = OceanBaseOracleAgent.class.getDeclaredMethod("isDbmsOutputStatement", String.class);+ classify.setAccessible(true);++ Assertions.assertEquals(true, classify.invoke(null, "<<output_block>> BEGIN DBMS_OUTPUT.PUT_LINE('x'); END;"));+ Assertions.assertEquals(true, classify.invoke(null, "{call app.print_output() }"));+ Assertions.assertEquals(true, classify.invoke(null, "{ ? = call app.get_output() }"));+ Assertions.assertEquals(false, classify.invoke(null, "SELECT 1 FROM DUAL"));+ }++ @Test+ void continuesWhenOceanBaseReportsDbmsOutputAsUndeclared() throws Exception {+ String block = "BEGIN NULL; END;";+ AtomicInteger userStatementCalls = new AtomicInteger();+ AtomicInteger closedConnections = new AtomicInteger();+ Statement statement = proxy(Statement.class, (method, args) -> {+ if ("execute".equals(method.getName())) {+ String sql = String.valueOf(args[0]);+ if (sql.startsWith("BEGIN DBMS_OUTPUT.DISABLE")) {+ throw new SQLException("PLS-00201: identifier 'DBMS_OUTPUT' must be declared", "42000", 5543);+ }+ if (block.equals(sql)) userStatementCalls.incrementAndGet();+ return false;+ }+ if ("getUpdateCount".equals(method.getName())) return -1;+ if ("getWarnings".equals(method.getName())) return null;+ return defaultValue(method.getReturnType());+ });+ Connection connection = proxy(Connection.class, (method, args) -> {+ if ("createStatement".equals(method.getName())) return statement;+ if ("close".equals(method.getName())) {+ closedConnections.incrementAndGet();+ return null;+ }+ return defaultValue(method.getReturnType());+ });+ OceanBaseOracleAgent agent = new OceanBaseOracleAgent();+ TestSupport.setPrivateConnection(agent, connection);++ QueryResult result = agent.executeQuery(block, null, new ExecuteQueryOptions());++ Assertions.assertEquals(1, userStatementCalls.get());+ Assertions.assertEquals(0, closedConnections.get());+ Assertions.assertEquals(List.of("Message"), result.getColumns());+ Assertions.assertTrue(result.getRows().stream().flatMap(List::stream)+ .anyMatch(value -> String.valueOf(value).contains("could not be enabled")));+ }++ @Test+ void doesNotExecuteUserSqlAfterDbmsOutputSetupTimeout() throws Exception {+ String block = "BEGIN DBMS_OUTPUT.PUT_LINE('hello world'); END;";+ AtomicInteger userStatementCalls = new AtomicInteger();+ AtomicInteger closedConnections = new AtomicInteger();+ Statement statement = proxy(Statement.class, (method, args) -> {+ if ("execute".equals(method.getName())) {+ String sql = String.valueOf(args[0]);+ if (block.equals(sql)) userStatementCalls.incrementAndGet();+ if (sql.startsWith("ALTER SESSION SET ob_query_timeout")) return false;+ throw new SQLTimeoutException("setup timed out", "HYT00");+ }+ return defaultValue(method.getReturnType());+ });+ Connection connection = proxy(Connection.class, (method, args) -> {+ if ("createStatement".equals(method.getName())) return statement;+ if ("close".equals(method.getName())) {+ closedConnections.incrementAndGet();+ return null;+ }+ return defaultValue(method.getReturnType());+ });+ OceanBaseOracleAgent agent = new OceanBaseOracleAgent();+ TestSupport.setPrivateConnection(agent, connection);++ Assertions.assertThrows(RuntimeException.class,+ () -> agent.executeQuery(block, null, new ExecuteQueryOptions()));++ Assertions.assertEquals(0, userStatementCalls.get());+ Assertions.assertEquals(1, closedConnections.get());+ }++ @Test+ void doesNotReportTruncationWhenOutputEndsExactlyAtLimits() throws Exception {+ assertOutputLimit(List.of());+ assertOutputLimit(java.util.Collections.nCopies(256, "x"));+ assertOutputLimit(List.of("x".repeat(32_767), "x".repeat(32_767), "x".repeat(2)));+ }++ @Test+ void doesNotSplitSupplementaryUnicodeWhenTruncatingOutput() throws Exception {+ List<String> messages = readOutputLines(List.of("x".repeat(65_535), "😀"));++ Assertions.assertEquals(65_535, messages.get(0).length());+ Assertions.assertFalse(messages.get(0).contains("\uD800"));+ Assertions.assertEquals("", messages.get(1));+ Assertions.assertTrue(messages.get(2).contains("truncated"));+ }++ @Test+ void reportsTruncationOnlyWhenAnotherLineExistsPastLineLimit() throws Exception {+ List<String> outputLines = new ArrayList<>(java.util.Collections.nCopies(257, "x"));+ AtomicInteger callCount = new AtomicInteger();+ Connection[] connectionRef = new Connection[1];+ CallableStatement output = proxy(CallableStatement.class, (method, args) -> {+ if ("execute".equals(method.getName())) {+ callCount.incrementAndGet();+ return false;+ }+ if ("getInt".equals(method.getName())) return callCount.get() <= outputLines.size() ? 0 : 1;+ if ("getString".equals(method.getName())) return outputLines.get(callCount.get() - 1);+ return defaultValue(method.getReturnType());+ });+ Statement statement = proxy(Statement.class, (method, args) ->+ "getConnection".equals(method.getName()) ? connectionRef[0] : defaultValue(method.getReturnType()));+ Connection connection = proxy(Connection.class, (method, args) -> {+ if ("prepareCall".equals(method.getName())) return output;+ if ("createStatement".equals(method.getName())) return proxy(Statement.class, (m, a) -> defaultValue(m.getReturnType()));+ return defaultValue(method.getReturnType());+ });+ connectionRef[0] = connection;+ OceanBaseOracleAgent agent = new OceanBaseOracleAgent();+ setField(agent, "captureDbmsOutput", true);+ setField(agent, "dbmsOutputEnabled", true);+ Method readerMethod = OceanBaseOracleAgent.class.getDeclaredMethod("statementMessageReader");+ readerMethod.setAccessible(true);++ @SuppressWarnings("unchecked")+ List<String> messages = ((com.dbx.agent.JdbcExecutor.StatementMessageReader) readerMethod.invoke(agent)).read(statement);++ Assertions.assertEquals(257, callCount.get());+ Assertions.assertEquals(257, messages.size());+ Assertions.assertEquals("DBMS_OUTPUT truncated at the output limit", messages.get(256));+ }++ private static void assertOutputLimit(List<String> outputLines) throws Exception {+ List<String> messages = readOutputLines(outputLines);+ Assertions.assertEquals(outputLines, messages);+ Assertions.assertFalse(messages.stream().anyMatch(message -> message.contains("truncated")));+ }++ private static List<String> readOutputLines(List<String> outputLines) throws Exception {+ AtomicInteger callCount = new AtomicInteger();+ Connection[] connectionRef = new Connection[1];+ CallableStatement output = proxy(CallableStatement.class, (method, args) -> {+ if ("execute".equals(method.getName())) {+ callCount.incrementAndGet();+ return false;+ }+ if ("getInt".equals(method.getName())) return callCount.get() <= outputLines.size() ? 0 : 1;+ if ("getString".equals(method.getName())) return outputLines.get(callCount.get() - 1);+ return defaultValue(method.getReturnType());+ });+ Statement statement = proxy(Statement.class, (method, args) ->+ "getConnection".equals(method.getName()) ? connectionRef[0] : defaultValue(method.getReturnType()));+ Connection connection = proxy(Connection.class, (method, args) -> {+ if ("prepareCall".equals(method.getName())) return output;+ if ("createStatement".equals(method.getName())) return proxy(Statement.class, (m, a) -> defaultValue(m.getReturnType()));+ return defaultValue(method.getReturnType());+ });+ connectionRef[0] = connection;+ OceanBaseOracleAgent agent = new OceanBaseOracleAgent();+ setField(agent, "captureDbmsOutput", true);+ setField(agent, "dbmsOutputEnabled", true);+ Method readerMethod = OceanBaseOracleAgent.class.getDeclaredMethod("statementMessageReader");+ readerMethod.setAccessible(true);++ @SuppressWarnings("unchecked")+ List<String> messages = ((com.dbx.agent.JdbcExecutor.StatementMessageReader) readerMethod.invoke(agent)).read(statement);++ int characters = outputLines.stream().mapToInt(String::length).sum();+ int expectedCalls = outputLines.size() > 256 || characters > 65_536+ ? Math.min(outputLines.size(), 256)+ : outputLines.size() + 1;+ Assertions.assertEquals(expectedCalls, callCount.get());+ return messages;+ }++ @Test+ void discardsConnectionWhenDbmsOutputCleanupFails() throws Exception {+ String block = "BEGIN DBMS_OUTPUT.PUT_LINE('hello world'); END;";+ AtomicInteger outputSetupCalls = new AtomicInteger();+ AtomicInteger userStatementCalls = new AtomicInteger();+ AtomicInteger closedConnections = new AtomicInteger();+ Connection[] connectionRef = new Connection[1];+ CallableStatement output = proxy(CallableStatement.class, (method, args) -> {+ if ("execute".equals(method.getName())) throw new SQLException("GET_LINE failed");+ return defaultValue(method.getReturnType());+ });+ Statement statement = proxy(Statement.class, (method, args) -> {+ if ("execute".equals(method.getName())) {+ String sql = String.valueOf(args[0]);+ if (sql.startsWith("BEGIN DBMS_OUTPUT.DISABLE")) {+ if (outputSetupCalls.incrementAndGet() > 1) throw new SQLException("cleanup failed");+ }+ if (block.equals(sql)) userStatementCalls.incrementAndGet();+ return false;+ }+ if ("getConnection".equals(method.getName())) return connectionRef[0];+ if ("getUpdateCount".equals(method.getName())) return -1;+ if ("getWarnings".equals(method.getName())) return null;+ return defaultValue(method.getReturnType());+ });+ Connection connection = proxy(Connection.class, (method, args) -> {+ if ("createStatement".equals(method.getName())) return statement;+ if ("prepareCall".equals(method.getName())) return output;+ if ("close".equals(method.getName())) {+ closedConnections.incrementAndGet();+ return null;+ }+ return defaultValue(method.getReturnType());+ });+ connectionRef[0] = connection;+ OceanBaseOracleAgent agent = new OceanBaseOracleAgent();+ TestSupport.setPrivateConnection(agent, connection);++ QueryResult result = agent.executeQuery(block, null, new ExecuteQueryOptions());++ Assertions.assertEquals(List.of("Message"), result.getColumns());+ Assertions.assertTrue(result.getRows().stream().flatMap(List::stream)+ .anyMatch(value -> String.valueOf(value).contains("DBMS_OUTPUT cleanup failed")));+ Assertions.assertEquals(1, closedConnections.get(), "a connection with unknown DBMS_OUTPUT state must be discarded");+ Assertions.assertEquals(2, outputSetupCalls.get(), "one initial enable and one failed reset are expected");+ Assertions.assertEquals(1, userStatementCalls.get(), "cleanup failure must not retry the user statement");+ }++ @Test+ void cleansDbmsOutputWhenPagedPlsqlReturnsAResultSet() throws Exception {+ String block = "BEGIN OPEN :cursor FOR SELECT 1 FROM DUAL; END;";+ List<String> executedSql = new ArrayList<>();+ int[] row = {-1};+ AtomicInteger outputCalls = new AtomicInteger();+ ResultSetMetaData meta = proxy(ResultSetMetaData.class, (method, args) -> {+ if ("getColumnCount".equals(method.getName())) return 1;+ if ("getColumnLabel".equals(method.getName())) return "N";+ if ("getColumnType".equals(method.getName())) return Types.INTEGER;+ if ("getColumnTypeName".equals(method.getName())) return "NUMBER";+ return defaultValue(method.getReturnType());+ });+ ResultSet cursor = proxy(ResultSet.class, (method, args) -> {+ if ("next".equals(method.getName())) return ++row[0] == 0;+ if ("getMetaData".equals(method.getName())) return meta;+ if ("getObject".equals(method.getName()) || "getInt".equals(method.getName())) return 1;+ return defaultValue(method.getReturnType());+ });+ CallableStatement output = proxy(CallableStatement.class, (method, args) -> {+ if ("execute".equals(method.getName())) {+ outputCalls.incrementAndGet();+ return false;+ }+ if ("getInt".equals(method.getName())) return outputCalls.get() == 1 ? 0 : 1;+ if ("getString".equals(method.getName())) return "cursor output";+ return defaultValue(method.getReturnType());+ });+ Connection[] connectionRef = new Connection[1];+ Statement statement = proxy(Statement.class, (method, args) -> {+ if ("execute".equals(method.getName())) {+ String sql = String.valueOf(args[0]);+ executedSql.add(sql);+ return block.equals(sql);+ }+ if ("getResultSet".equals(method.getName())) return cursor;+ if ("getConnection".equals(method.getName())) return connectionRef[0];+ if ("getUpdateCount".equals(method.getName())) return -1;+ return defaultValue(method.getReturnType());+ });+ Connection connection = proxy(Connection.class, (method, args) -> {+ if ("createStatement".equals(method.getName())) return statement;+ if ("prepareCall".equals(method.getName())) return output;+ return defaultValue(method.getReturnType());+ });+ connectionRef[0] = connection;+ OceanBaseOracleAgent agent = new OceanBaseOracleAgent();+ TestSupport.setPrivateConnection(agent, connection);++ QueryPageResult result = agent.executeQueryPage(block, null, new QueryPageOptions(10, null, 10, 0));++ Assertions.assertEquals(List.of("N"), result.getColumns());+ Assertions.assertEquals(List.of(List.of(1)), result.getRows());+ Assertions.assertTrue(result.getMessages().stream().anyMatch(message -> "cursor output".equals(message.get("message"))));+ Assertions.assertEquals(2, outputCalls.get());+ Assertions.assertTrue(executedSql.contains("BEGIN DBMS_OUTPUT.DISABLE; END;"),+ "closing the completed result-set session must disable DBMS_OUTPUT");+ }+@Testvoid buildsOceanBaseJdbcUrl() {ConnectParams params = new ConnectParams();