feat(dameng): support dm6 connections via custom jdbc drivers
This commit is contained in:
20 files changed
+560
-21
No files matched your search
@@ -7,6 +7,7 @@ import com.dbx.agent.DatabaseInfo;
|
||||
import com.dbx.agent.ExecuteQueryOptions;
|
||||
import com.dbx.agent.ForeignKeyInfo;
|
||||
import com.dbx.agent.IndexInfo;
|
||||
import com.dbx.agent.JdbcAgentProfile;
|
||||
import com.dbx.agent.JdbcExecutor;
|
||||
import com.dbx.agent.JdbcIdentifiers;
|
||||
import com.dbx.agent.MultiSessionJsonRpcServer;
|
||||
@@ -18,14 +19,18 @@ import com.dbx.agent.QueryPageResult;
|
||||
import com.dbx.agent.QueryResult;
|
||||
import com.dbx.agent.TableInfo;
|
||||
import com.dbx.agent.TriggerInfo;
|
||||
import dm.jdbc.driver.DmdbConnection;
|
||||
import com.dbx.agent.StandardJdbcMetadata;
|
||||
import java.io.PrintStream;
|
||||
import java.io.Reader;
|
||||
import java.net.URL;
|
||||
import java.net.URLClassLoader;
|
||||
import java.net.SocketTimeoutException;
|
||||
import java.nio.file.Paths;
|
||||
import java.sql.Blob;
|
||||
import java.sql.Clob;
|
||||
import java.sql.Connection;
|
||||
import java.sql.DatabaseMetaData;
|
||||
import java.sql.Driver;
|
||||
import java.sql.DriverManager;
|
||||
import java.sql.PreparedStatement;
|
||||
import java.sql.ResultSet;
|
||||
@@ -49,16 +54,26 @@ import java.util.LinkedHashSet;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import java.util.Map;
|
||||
import java.util.Properties;
|
||||
import java.util.Set;
|
||||
import java.util.WeakHashMap;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
public final class DamengAgent extends AbstractJdbcAgent {
|
||||
private static final Logger LOGGER = Logger.getLogger("com.dbx.agent.dameng");
|
||||
private static final String AGENT_VERSION = "9999.06.04.1-fix-default";
|
||||
private static final int DBMS_OUTPUT_ENABLE_TIMEOUT_SECS = 5;
|
||||
private static final int DBMS_OUTPUT_ENABLE_NETWORK_TIMEOUT_MILLIS = 5_000;
|
||||
private static final Pattern DATABASE_VERSION_MAJOR_PATTERN = Pattern.compile("(\\d+)\\.");
|
||||
private static final JdbcAgentProfile DM6_METADATA_PROFILE = new JdbcAgentProfile(
|
||||
"dm6.jdbc.driver.DmDriver",
|
||||
"jdbc:dm6://{host}:{port}/{database}",
|
||||
5236,
|
||||
true
|
||||
);
|
||||
private static final String DAMENG_CLASSIFIED_OBJECT_TYPE_SQL =
|
||||
"CASE WHEN o.OBJECT_TYPE = 'MATERIALIZED VIEW' OR (o.OBJECT_TYPE = 'VIEW' AND mv.MVIEW_NAME IS NOT NULL) "
|
||||
+ "THEN 'MATERIALIZED_VIEW' ELSE o.OBJECT_TYPE END";
|
||||
@@ -90,6 +105,11 @@ public final class DamengAgent extends AbstractJdbcAgent {
|
||||
) mv ON mv.OWNER = o.OWNER AND mv.MVIEW_NAME = o.OBJECT_NAME
|
||||
""".stripIndent().trim();
|
||||
private String connectedUsername;
|
||||
private Driver externalDriver;
|
||||
private URLClassLoader externalDriverLoader;
|
||||
private List<URL> externalDriverUrls;
|
||||
private String externalDriverClass;
|
||||
private volatile boolean legacyJdbcMetadata;
|
||||
private volatile boolean dbmsOutputInitializationSupported = true;
|
||||
private final Map<Object, Boolean> dbmsOutputInitializedConnections =
|
||||
Collections.synchronizedMap(new WeakHashMap<>());
|
||||
@@ -106,19 +126,120 @@ public final class DamengAgent extends AbstractJdbcAgent {
|
||||
|
||||
@Override
|
||||
protected void loadDriver(ConnectParams params) throws Exception {
|
||||
withSuppressedStdout(() -> super.loadDriver(params));
|
||||
withSuppressedStdout(() -> {
|
||||
if (params.getJdbc_driver_paths() == null || params.getJdbc_driver_paths().isEmpty()) {
|
||||
// Keep an existing external loader open: pooled connections may
|
||||
// still hold classes loaded from it. Only stop using it here.
|
||||
externalDriver = null;
|
||||
super.loadDriver(params);
|
||||
return;
|
||||
}
|
||||
|
||||
List<URL> urls = new ArrayList<>();
|
||||
for (String path : params.getJdbc_driver_paths()) {
|
||||
urls.add(Paths.get(path).toUri().toURL());
|
||||
}
|
||||
String driverClass = params.getJdbc_driver_class();
|
||||
if (driverClass == null || driverClass.trim().isEmpty()) {
|
||||
driverClass = driverClass();
|
||||
}
|
||||
// Reuse the loader for unchanged paths and class: recreating it
|
||||
// would strand classes that live pooled connections still need
|
||||
// (lazy driver classes would fail with NoClassDefFoundError). A
|
||||
// loader dropped for changed paths is never closed here for the
|
||||
// same reason; disconnect() releases the active one.
|
||||
if (externalDriverLoader != null
|
||||
&& urls.equals(externalDriverUrls)
|
||||
&& driverClass.equals(externalDriverClass)) {
|
||||
if (externalDriver == null) {
|
||||
externalDriver = (Driver) Class.forName(driverClass, true, externalDriverLoader)
|
||||
.getDeclaredConstructor()
|
||||
.newInstance();
|
||||
}
|
||||
return;
|
||||
}
|
||||
externalDriverLoader = new URLClassLoader(
|
||||
urls.toArray(new URL[0]),
|
||||
ClassLoader.getPlatformClassLoader()
|
||||
);
|
||||
externalDriverUrls = urls;
|
||||
externalDriverClass = driverClass;
|
||||
externalDriver = (Driver) Class.forName(driverClass, true, externalDriverLoader)
|
||||
.getDeclaredConstructor()
|
||||
.newInstance();
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
protected Connection openConnection(ConnectParams params) throws Exception {
|
||||
return withSuppressedStdout(
|
||||
() -> DriverManager.getConnection(buildUrl(params), params.getUsername(), params.getPassword())
|
||||
);
|
||||
return withSuppressedStdout(() -> {
|
||||
if (externalDriver == null) {
|
||||
return DriverManager.getConnection(buildUrl(params), params.getUsername(), params.getPassword());
|
||||
}
|
||||
Properties properties = new Properties();
|
||||
if (params.getUsername() != null) {
|
||||
properties.setProperty("user", params.getUsername());
|
||||
}
|
||||
if (params.getPassword() != null) {
|
||||
properties.setProperty("password", params.getPassword());
|
||||
}
|
||||
Connection connection = externalDriver.connect(buildUrl(params), properties);
|
||||
if (connection == null) {
|
||||
throw new SQLException("Selected Dameng JDBC driver does not accept URL: " + buildUrl(params));
|
||||
}
|
||||
return connection;
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
protected String connectionValidationQuery() {
|
||||
return "SELECT 1";
|
||||
}
|
||||
|
||||
@Override
|
||||
public synchronized void disconnect() {
|
||||
super.disconnect();
|
||||
try {
|
||||
closeExternalDriverLoader();
|
||||
} catch (Exception error) {
|
||||
// Best-effort release during teardown.
|
||||
}
|
||||
}
|
||||
|
||||
private void closeExternalDriverLoader() throws Exception {
|
||||
externalDriver = null;
|
||||
externalDriverUrls = null;
|
||||
externalDriverClass = null;
|
||||
if (externalDriverLoader != null) {
|
||||
externalDriverLoader.close();
|
||||
externalDriverLoader = null;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void afterConnect(ConnectParams params, Connection connection) {
|
||||
connectedUsername = params.getUsername();
|
||||
legacyJdbcMetadata = usesLegacyJdbcMetadata(connection);
|
||||
}
|
||||
|
||||
static boolean usesLegacyJdbcMetadata(Connection connection) {
|
||||
try {
|
||||
int major = connection.getMetaData().getDatabaseMajorVersion();
|
||||
if (major > 0) {
|
||||
return major < 7;
|
||||
}
|
||||
} catch (Exception | AbstractMethodError ignored) {
|
||||
}
|
||||
try {
|
||||
String version = connection.getMetaData().getDatabaseProductVersion();
|
||||
if (version == null) {
|
||||
return false;
|
||||
}
|
||||
Matcher matcher = DATABASE_VERSION_MAJOR_PATTERN.matcher(version);
|
||||
return matcher.find() && Integer.parseInt(matcher.group(1)) < 7;
|
||||
} catch (Exception | AbstractMethodError ignored) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -127,12 +248,12 @@ public final class DamengAgent extends AbstractJdbcAgent {
|
||||
}
|
||||
|
||||
private void initializeDbmsOutputIfNeeded(String sql) throws SQLException {
|
||||
if (!dbmsOutputInitializationSupported || !isDbmsOutputStatement(sql)) {
|
||||
if (legacyJdbcMetadata || !dbmsOutputInitializationSupported || !isDbmsOutputStatement(sql)) {
|
||||
return;
|
||||
}
|
||||
|
||||
Connection connection = requireConnected();
|
||||
Object physicalConnection = connection.unwrap(DmdbConnection.class);
|
||||
Object physicalConnection = physicalConnectionIdentity(connection);
|
||||
synchronized (dbmsOutputInitializedConnections) {
|
||||
if (dbmsOutputInitializedConnections.containsKey(physicalConnection)) {
|
||||
return;
|
||||
@@ -190,6 +311,22 @@ public final class DamengAgent extends AbstractJdbcAgent {
|
||||
|| startsWithKeyword(sql, start, "EXECUTE");
|
||||
}
|
||||
|
||||
private Object physicalConnectionIdentity(Connection connection) {
|
||||
try {
|
||||
String driverClassName = externalDriver == null ? driverClass() : externalDriver.getClass().getName();
|
||||
int packageSeparator = driverClassName.lastIndexOf('.');
|
||||
if (packageSeparator < 0) {
|
||||
return connection;
|
||||
}
|
||||
String connectionClassName = driverClassName.substring(0, packageSeparator + 1) + "DmdbConnection";
|
||||
ClassLoader loader = externalDriverLoader == null ? getClass().getClassLoader() : externalDriverLoader;
|
||||
Class<?> connectionClass = Class.forName(connectionClassName, false, loader);
|
||||
return connection.unwrap(connectionClass);
|
||||
} catch (Exception | AbstractMethodError ignored) {
|
||||
return connection;
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean startsWithKeyword(String sql, int start, String keyword) {
|
||||
int end = start + keyword.length();
|
||||
return end <= sql.length()
|
||||
@@ -321,11 +458,17 @@ public final class DamengAgent extends AbstractJdbcAgent {
|
||||
|
||||
@Override
|
||||
public List<DatabaseInfo> listDatabases() {
|
||||
if (legacyJdbcMetadata) {
|
||||
return unchecked(() -> listJdbcSchemas().stream().map(DatabaseInfo::new).toList());
|
||||
}
|
||||
return unchecked(() -> listVisibleUsers().stream().map(DatabaseInfo::new).toList());
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> listSchemas() {
|
||||
if (legacyJdbcMetadata) {
|
||||
return StandardJdbcMetadata.INSTANCE.listSchemas(requireConnected(), DM6_METADATA_PROFILE);
|
||||
}
|
||||
return unchecked(() -> {
|
||||
try {
|
||||
return listVisibleSchemas();
|
||||
@@ -395,6 +538,9 @@ public final class DamengAgent extends AbstractJdbcAgent {
|
||||
}
|
||||
|
||||
private List<TableInfo> queryConstrainedTables(String schema, MetadataListConstraints constraints) {
|
||||
if (legacyJdbcMetadata) {
|
||||
return executeJdbcMetadataTables(schema, constraints);
|
||||
}
|
||||
if (!constraints.includesTableLikeTypes()) {
|
||||
return List.of();
|
||||
}
|
||||
@@ -913,6 +1059,9 @@ public final class DamengAgent extends AbstractJdbcAgent {
|
||||
}
|
||||
|
||||
private List<ObjectInfo> queryConstrainedObjects(String schema, MetadataListConstraints constraints) {
|
||||
if (legacyJdbcMetadata) {
|
||||
return executeJdbcMetadataObjects(schema, constraints);
|
||||
}
|
||||
if (!includesSupportedObjectTypes(constraints)) {
|
||||
return List.of();
|
||||
}
|
||||
@@ -1451,6 +1600,9 @@ public final class DamengAgent extends AbstractJdbcAgent {
|
||||
|
||||
@Override
|
||||
public String getTableDdl(String schema, String table) {
|
||||
if (legacyJdbcMetadata) {
|
||||
return super.getTableDdl(schema, table);
|
||||
}
|
||||
try {
|
||||
return unchecked(() -> {
|
||||
String sql = "SELECT /*+ PARALLEL(1) */ DBMS_METADATA.GET_DDL(?, ?, ?) FROM DUAL";
|
||||
@@ -1486,6 +1638,15 @@ public final class DamengAgent extends AbstractJdbcAgent {
|
||||
|
||||
@Override
|
||||
public List<ColumnInfo> getColumns(String schema, String table) {
|
||||
if (legacyJdbcMetadata) {
|
||||
return StandardJdbcMetadata.INSTANCE.getColumns(
|
||||
requireConnected(),
|
||||
DM6_METADATA_PROFILE,
|
||||
getConfiguredDatabase(),
|
||||
schema,
|
||||
table
|
||||
);
|
||||
}
|
||||
return unchecked(() -> {
|
||||
Set<String> pkColumns = new java.util.HashSet<>();
|
||||
String pkSql = """
|
||||
@@ -1590,6 +1751,15 @@ public final class DamengAgent extends AbstractJdbcAgent {
|
||||
|
||||
@Override
|
||||
public List<IndexInfo> listIndexes(String schema, String table) {
|
||||
if (legacyJdbcMetadata) {
|
||||
return StandardJdbcMetadata.INSTANCE.listIndexes(
|
||||
requireConnected(),
|
||||
DM6_METADATA_PROFILE,
|
||||
getConfiguredDatabase(),
|
||||
schema,
|
||||
table
|
||||
);
|
||||
}
|
||||
return unchecked(() -> {
|
||||
List<IndexInfo> result = new ArrayList<>();
|
||||
String sql = """
|
||||
@@ -1630,6 +1800,9 @@ public final class DamengAgent extends AbstractJdbcAgent {
|
||||
|
||||
@Override
|
||||
public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
|
||||
if (legacyJdbcMetadata) {
|
||||
return StandardJdbcMetadata.INSTANCE.listForeignKeys(requireConnected(), schema, table);
|
||||
}
|
||||
return unchecked(() -> {
|
||||
List<ForeignKeyInfo> result = new ArrayList<>();
|
||||
String sql = """
|
||||
@@ -1661,6 +1834,9 @@ public final class DamengAgent extends AbstractJdbcAgent {
|
||||
|
||||
@Override
|
||||
public List<TriggerInfo> listTriggers(String schema, String table) {
|
||||
if (legacyJdbcMetadata) {
|
||||
return StandardJdbcMetadata.INSTANCE.listTriggers(schema, table);
|
||||
}
|
||||
return unchecked(() -> {
|
||||
List<TriggerInfo> result = new ArrayList<>();
|
||||
String sql = """
|
||||
@@ -1722,7 +1898,7 @@ public final class DamengAgent extends AbstractJdbcAgent {
|
||||
}
|
||||
String message = (String) value;
|
||||
return message.isEmpty() ? List.of() : message.lines().toList();
|
||||
} catch (Exception ignored) {
|
||||
} catch (Exception | AbstractMethodError ignored) {
|
||||
return List.of();
|
||||
}
|
||||
}
|
||||
@@ -1921,6 +2097,10 @@ public final class DamengAgent extends AbstractJdbcAgent {
|
||||
}
|
||||
|
||||
private static String buildUrl(ConnectParams params) {
|
||||
String connectionString = params.getConnection_string() == null ? "" : params.getConnection_string().trim();
|
||||
if (!connectionString.isEmpty()) {
|
||||
return connectionString;
|
||||
}
|
||||
String database = params.getDatabase() == null ? "" : params.getDatabase().trim();
|
||||
String suffix = database.isEmpty() ? "" : "/" + database;
|
||||
String url = "jdbc:dm://" + params.getHost() + ":" + params.getPort() + suffix;
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
package com.dbx.agent.dameng;
|
||||
|
||||
import com.dbx.agent.ColumnInfo;
|
||||
import com.dbx.agent.DatabaseInfo;
|
||||
import com.dbx.agent.MetadataListConstraints;
|
||||
import com.dbx.agent.ObjectInfo;
|
||||
import com.dbx.agent.ObjectSource;
|
||||
@@ -25,6 +26,31 @@ import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
class DamengAgentMetadataTest {
|
||||
@Test
|
||||
void detectsLegacyDamengMetadataFromDatabaseVersion() {
|
||||
Assertions.assertTrue(DamengAgent.usesLegacyJdbcMetadata(versionConnection(6, "6.0.2.79")));
|
||||
Assertions.assertFalse(DamengAgent.usesLegacyJdbcMetadata(versionConnection(8, "8.1.5.45")));
|
||||
Assertions.assertTrue(DamengAgent.usesLegacyJdbcMetadata(versionConnection(0, "DM Database Server x64 V6.0.2.79")));
|
||||
}
|
||||
|
||||
@Test
|
||||
void legacyDamengUsesJdbcMetadataWithoutQueryingDm8CatalogViews() {
|
||||
DamengAgent agent = new DamengAgent();
|
||||
List<String> metadataCalls = new ArrayList<>();
|
||||
TestSupport.setPrivateConnection(agent, legacyMetadataConnection(metadataCalls));
|
||||
setLegacyJdbcMetadata(agent, true);
|
||||
|
||||
List<DatabaseInfo> databases = agent.listDatabases();
|
||||
List<String> schemas = agent.listSchemas();
|
||||
List<TableInfo> tables = agent.listTables("DBX_TEST");
|
||||
|
||||
Assertions.assertEquals(List.of("DBX_TEST", "SYSDBA"), databases.stream().map(DatabaseInfo::getName).toList());
|
||||
Assertions.assertEquals(List.of("DBX_TEST", "SYSDBA"), schemas);
|
||||
Assertions.assertEquals(List.of("CONNECTION_SMOKE"), tables.stream().map(TableInfo::getName).toList());
|
||||
Assertions.assertTrue(metadataCalls.contains("getSchemas"), metadataCalls.toString());
|
||||
Assertions.assertTrue(metadataCalls.contains("getTables:DBX\\_TEST"), metadataCalls.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
void usesColumnCommentsMetadataQuery() {
|
||||
DamengAgent agent = new DamengAgent();
|
||||
@@ -1335,6 +1361,56 @@ class DamengAgentMetadataTest {
|
||||
}
|
||||
}
|
||||
|
||||
private static void setLegacyJdbcMetadata(DamengAgent agent, boolean value) {
|
||||
try {
|
||||
Field field = DamengAgent.class.getDeclaredField("legacyJdbcMetadata");
|
||||
field.setAccessible(true);
|
||||
field.set(agent, value);
|
||||
} catch (ReflectiveOperationException e) {
|
||||
throw new IllegalStateException("Unable to set legacy JDBC metadata mode", e);
|
||||
}
|
||||
}
|
||||
|
||||
private static Connection versionConnection(int majorVersion, String productVersion) {
|
||||
DatabaseMetaData metadata = proxy(DatabaseMetaData.class, (method, args) -> switch (method.getName()) {
|
||||
case "getDatabaseMajorVersion" -> majorVersion;
|
||||
case "getDatabaseProductVersion" -> productVersion;
|
||||
default -> defaultValue(method.getReturnType());
|
||||
});
|
||||
return proxy(Connection.class, (method, args) ->
|
||||
"getMetaData".equals(method.getName()) ? metadata : defaultValue(method.getReturnType())
|
||||
);
|
||||
}
|
||||
|
||||
private static Connection legacyMetadataConnection(List<String> calls) {
|
||||
DatabaseMetaData metadata = proxy(DatabaseMetaData.class, (method, args) -> {
|
||||
switch (method.getName()) {
|
||||
case "getSchemas":
|
||||
calls.add("getSchemas");
|
||||
return metadataResultSet(List.of(List.of("SYSDBA"), List.of("DBX_TEST")));
|
||||
case "getTableTypes":
|
||||
return metadataResultSet(List.of(List.of("", "TABLE", "")));
|
||||
case "getTables":
|
||||
Assertions.assertNull(args[3], "DM6 JDBC rejects non-null getTables types");
|
||||
calls.add("getTables:" + args[1]);
|
||||
return metadataResultSet(List.of(List.of("CONNECTION_SMOKE", "TABLE", "smoke table")));
|
||||
case "getSearchStringEscape":
|
||||
return "\\";
|
||||
default:
|
||||
return defaultValue(method.getReturnType());
|
||||
}
|
||||
});
|
||||
return proxy(Connection.class, (method, args) -> {
|
||||
if ("getMetaData".equals(method.getName())) {
|
||||
return metadata;
|
||||
}
|
||||
if ("prepareStatement".equals(method.getName())) {
|
||||
throw new AssertionError("Legacy metadata mode must not query DM8 catalog views: " + args[0]);
|
||||
}
|
||||
return defaultValue(method.getReturnType());
|
||||
});
|
||||
}
|
||||
|
||||
private static Connection objectSourceConnection(List<String> params, String source) {
|
||||
return proxy(Connection.class, (method, args) -> {
|
||||
String name = method.getName();
|
||||
|
||||
@@ -12,6 +12,7 @@ import com.dbx.agent.test.JdbcAgentFake;
|
||||
import com.dbx.agent.test.TestSupport;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.InvocationHandler;
|
||||
import java.lang.reflect.Method;
|
||||
import java.lang.reflect.Proxy;
|
||||
@@ -100,6 +101,18 @@ class DamengAgentTest extends JdbcFakeExecutionBehaviorTest {
|
||||
assertDoesNotEnableDbmsOutput("/* CALL hidden in a comment */ SELECT 1");
|
||||
}
|
||||
|
||||
@Test
|
||||
void legacyDamengSkipsUnavailableDbmsOutputInitialization() {
|
||||
List<String> executedSql = new ArrayList<>();
|
||||
DamengAgent agent = new DamengAgent();
|
||||
TestSupport.setPrivateConnection(agent, printMessageConnection(null, executedSql));
|
||||
setLegacyJdbcMetadata(agent, true);
|
||||
|
||||
agent.executeQuery("BEGIN NULL; END;", null, new ExecuteQueryOptions());
|
||||
|
||||
assertEquals(List.of("BEGIN NULL; END;"), executedSql);
|
||||
}
|
||||
|
||||
@Test
|
||||
void outputStatementsEnableDbmsOutputOncePerPhysicalConnection() {
|
||||
List<String> firstConnectionSql = new ArrayList<>();
|
||||
@@ -216,6 +229,22 @@ class DamengAgentTest extends JdbcFakeExecutionBehaviorTest {
|
||||
), executedSql);
|
||||
}
|
||||
|
||||
@Test
|
||||
void legacyStatementWithoutJdbc4UnwrapReturnsNoPrintMessages() {
|
||||
Statement statement = (Statement) Proxy.newProxyInstance(
|
||||
DamengAgentTest.class.getClassLoader(),
|
||||
new Class<?>[]{Statement.class},
|
||||
(unused, method, args) -> {
|
||||
if ("unwrap".equals(method.getName())) {
|
||||
throw new AbstractMethodError("legacy JDBC driver");
|
||||
}
|
||||
return defaultValue(method.getReturnType());
|
||||
}
|
||||
);
|
||||
|
||||
assertEquals(List.of(), DamengAgent.statementPrintMessages(statement));
|
||||
}
|
||||
|
||||
@Test
|
||||
void pagedOutputStatementsEnableDbmsOutputLazily() {
|
||||
List<String> executedSql = new ArrayList<>();
|
||||
@@ -620,6 +649,16 @@ class DamengAgentTest extends JdbcFakeExecutionBehaviorTest {
|
||||
assertEquals(List.of("BEGIN DBMS_OUTPUT.ENABLE(1000000); END;"), executedSql);
|
||||
}
|
||||
|
||||
private static void setLegacyJdbcMetadata(DamengAgent agent, boolean value) {
|
||||
try {
|
||||
Field field = DamengAgent.class.getDeclaredField("legacyJdbcMetadata");
|
||||
field.setAccessible(true);
|
||||
field.set(agent, value);
|
||||
} catch (ReflectiveOperationException error) {
|
||||
throw new IllegalStateException("Unable to set legacy JDBC metadata mode", error);
|
||||
}
|
||||
}
|
||||
|
||||
private static Object defaultValue(Class<?> type) {
|
||||
if (type == Boolean.TYPE) return false;
|
||||
if (type == Byte.TYPE) return (byte) 0;
|
||||
|
||||
@@ -21,6 +21,24 @@ class DamengAgentUrlTest {
|
||||
Assertions.assertEquals("jdbc:dm://127.0.0.1:5236/MAIN", url);
|
||||
}
|
||||
|
||||
@Test
|
||||
void usesCompleteCustomJdbcUrlWithoutRewritingIt() throws Exception {
|
||||
ConnectParams params = new ConnectParams(
|
||||
"ignored",
|
||||
5236,
|
||||
"IGNORED",
|
||||
"",
|
||||
"",
|
||||
"ssl=true",
|
||||
"jdbc:dm6://dm6.internal:5237/MAIN?compatibleMode=oracle",
|
||||
false
|
||||
);
|
||||
|
||||
String url = invokeBuildUrl(params);
|
||||
|
||||
Assertions.assertEquals("jdbc:dm6://dm6.internal:5237/MAIN?compatibleMode=oracle", url);
|
||||
}
|
||||
|
||||
@Test
|
||||
void appendsDmJdbcUrlParameters() throws Exception {
|
||||
String url = invokeBuildUrl(new ConnectParams(
|
||||
|
||||
Reference in new issue
Block a user