feat(dameng): support dm6 connections via custom jdbc drivers

This commit is contained in:
zipg authored and GitHub committed 2026-08-26 12:43:31 +08:00
1 parent c8c9870dba
commit 5b61f17c49
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(