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(jdbc): render generic table DDL for unmatched external JDBC drivers
t8y23be523b2f523
diff --git a/crates/dbx-core/src/schema.rs b/crates/dbx-core/src/schema.rsindex 1358d7ad3a..1d0e57f28a 100644--- a/crates/dbx-core/src/schema.rs+++ b/crates/dbx-core/src/schema.rs@@ -3166,12 +3166,12 @@ mod tests {clickhouse_metadata_database, dameng_object_statistics_dba_segments_sql,dameng_object_statistics_rows_only_sql, dameng_object_statistics_user_segments_sql, deduplicate_column_infos,ephemeral_agent_metadata_session_id, external_driver_statistics_dialect, external_driver_statistics_query_plan,- external_driver_uses_mysql_ddl, filter_mongodb_agent_collections, filter_mysql_system_databases_for_config,- filter_object_infos, filter_table_infos, filter_visible_schema_names, finalize_object_source,- gaussdb_m_view_object_source_sql, gbase8a_object_statistics_sql, is_agent_postgres_metadata_fallback_config,- is_mysql_external_driver_config, is_oracle_external_driver_config, is_retryable_metadata_error,- metadata_error_action, metadata_name_or_comment_matches, mysql_database_list_timeout,- mysql_external_driver_ddl_from_query_result, mysql_external_driver_ddl_sql,+ external_driver_uses_generic_ddl, external_driver_uses_mysql_ddl, filter_mongodb_agent_collections,+ filter_mysql_system_databases_for_config, filter_object_infos, filter_table_infos, filter_visible_schema_names,+ finalize_object_source, gaussdb_m_view_object_source_sql, gbase8a_object_statistics_sql,+ is_agent_postgres_metadata_fallback_config, is_mysql_external_driver_config, is_oracle_external_driver_config,+ is_retryable_metadata_error, metadata_error_action, metadata_name_or_comment_matches,+ mysql_database_list_timeout, mysql_external_driver_ddl_from_query_result, mysql_external_driver_ddl_sql,mysql_object_source_ddl_column_index, mysql_object_source_sql, mysql_table_list_source_for_config,mysql_table_metadata_catalog, normalize_information_schema_table_type, oracle_columns_from_query_result,oracle_columns_sql, oracle_columns_sql_for_resolved_owner, oracle_current_schema_from_query_result,@@ -3603,6 +3603,30 @@ mod tests {assert!(!is_oracle_external_driver_config(&config));}+ #[test]+ fn external_driver_generic_ddl_applies_to_unmatched_jdbc_connections() {+ // JDBCX-style wrappers match no vendor DDL dialect and fall back to the+ // plugin's generic DatabaseMetaData renderer.+ let mut config = test_connection_config(DatabaseType::Jdbc);+ config.connection_string = Some("jdbcx:wrap-jdbc:jdbc:mysql://127.0.0.1:3306/demo".to_string());+ config.jdbc_driver_class = Some("io.github.jdbcx.WrappedDriver".to_string());+ assert!(external_driver_uses_generic_ddl(&config));+ assert!(!external_driver_uses_mysql_ddl(&config));+ assert!(!is_oracle_external_driver_config(&config));++ // Vendor dialects keep their dedicated SQL paths.+ config.connection_string = Some("jdbc:mysql://127.0.0.1:3306/demo".to_string());+ config.jdbc_driver_class = None;+ assert!(!external_driver_uses_generic_ddl(&config));++ config.connection_string = Some("jdbc:oracle:thin:@//127.0.0.1:1521/ORCL".to_string());+ assert!(!external_driver_uses_generic_ddl(&config));++ // Vendor-typed database never routes through the generic renderer.+ let oracle = test_connection_config(DatabaseType::Oracle);+ assert!(!external_driver_uses_generic_ddl(&oracle));+ }+#[test]fn external_driver_statistics_dialect_matches_jdbc_url_vendor() {let mut config = test_connection_config(DatabaseType::Jdbc);@@ -7804,6 +7828,11 @@ async fn get_table_ddl_once(let session = session.clone();return external_driver_mysql_ddl(session, config.as_ref(), database, schema, table).await;}+ if external_driver_uses_generic_ddl(config.as_ref()) {+ let config = config.clone();+ let session = session.clone();+ return external_driver_jdbc_ddl(session, config.as_ref(), database, schema, table).await;+ }}#[cfg(feature = "duckdb-sidecar")]if let Some(client) = extract_pool!(pool_handle.as_ref(), DuckDbWorker) {@@ -11001,6 +11030,44 @@ async fn external_driver_oracle_ddl(.ok_or_else(|| "JDBC Oracle plugin returned no table DDL".to_string())}+/// External JDBC connections that match no vendor DDL dialect (JDBCX wrappers,+/// custom protocol drivers, …) have table DDL rendered by the plugin from+/// plain `DatabaseMetaData` via `getObjectSource`, mirroring the agent-side+/// `DdlBuilder` output.+fn external_driver_uses_generic_ddl(config: &ConnectionConfig) -> bool {+ config.db_type == DatabaseType::Jdbc+ && !is_oracle_external_driver_config(config)+ && !external_driver_uses_mysql_ddl(config)+}++async fn external_driver_jdbc_ddl(+ session: std::sync::Arc<crate::plugins::PluginDriverSession>,+ config: &ConnectionConfig,+ database: &str,+ schema: &str,+ table: &str,+) -> Result<String, String> {+ let result: serde_json::Value = session+ .invoke_with_timeout(+ "getObjectSource",+ serde_json::json!({+ "connection": config,+ "database": database,+ "schema": schema,+ "name": table,+ "object_type": "TABLE",+ }),+ agent_metadata_timeout(Some(config)),+ )+ .await?;+ result+ .get("source")+ .and_then(serde_json::Value::as_str)+ .filter(|source| !source.trim().is_empty())+ .map(str::to_string)+ .ok_or_else(|| "JDBC plugin returned no table DDL".to_string())+}+fn normalize_mysql_display_ddl(sql: String) -> String {ensure_display_ddl_terminated(repair_mysql_ddl_comments(&sql))}diff --git a/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.javaindex a262148bea..a7cfc12fbe 100644--- a/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java+++ b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java@@ -4028,9 +4028,76 @@ public final class DbxJdbcPlugin {throw new SQLException("Object source not found");}+ if ("TABLE".equals(normalizeObjectType(objectType))) {+ return genericTableObjectSource(connection, database, schema, name);+ }+throw new SQLException("Object source is not supported by this JDBC driver");}+ /**+ * Table source for generic external JDBC drivers (JDBCX wrappers, custom+ * protocol drivers) that expose no vendor DDL statement: assemble CREATE+ * TABLE from {@code DatabaseMetaData} via the same readers the browse RPCs+ * use, so driver quirks (catalog fallback, PK marking, tolerance of+ * unimplemented metadata methods) apply identically.+ */+ private static JsonNode genericTableObjectSource(JsonNode connection, String database, String schema, String table)+ throws SQLException {+ JsonNode columns = getColumns(connection, database, schema, table);+ if (!columns.isArray() || columns.isEmpty()) {+ throw new SQLException("Object source not found");+ }+ JsonNode indexes = listIndexes(connection, database, schema, table);++ JsonNode foreignKeys;+ try (Connection conn = openConnection(connection)) {+ DatabaseMetaData meta = conn.getMetaData();+ JdbcDriverQuirks quirks = driverQuirks(connection);+ String catalog = metadataCatalog(database, quirks);+ String schemaPattern = resolveSchemaPattern(meta, database, schema, quirks);+ foreignKeys = listGenericForeignKeys(meta, catalog, schemaPattern, table);+ }++ String source = GenericJdbcDdlBuilder.buildTableDdl(+ emptyToNull(schema) != null ? schema : emptyToNull(database),+ table,+ columns,+ indexes,+ foreignKeys+ );+ ObjectNode item = MAPPER.createObjectNode();+ item.put("name", table);+ item.put("object_type", "TABLE");+ putNullable(item, "schema", emptyToNull(schema));+ item.put("source", source);+ return item;+ }++ private static JsonNode listGenericForeignKeys(DatabaseMetaData meta, String catalog, String schemaPattern, String table) {+ ArrayNode result = MAPPER.createArrayNode();+ try (ResultSet rs = meta.getImportedKeys(catalog, schemaPattern, table)) {+ while (rs != null && rs.next()) {+ String column = rs.getString("FKCOLUMN_NAME");+ String refTable = rs.getString("PKTABLE_NAME");+ String refColumn = rs.getString("PKCOLUMN_NAME");+ if (column == null || column.isBlank() || refTable == null || refTable.isBlank()+ || refColumn == null || refColumn.isBlank()) {+ continue;+ }+ ObjectNode item = MAPPER.createObjectNode();+ item.put("name", rs.getString("FK_NAME"));+ item.put("column", column);+ item.put("ref_table", refTable);+ item.put("ref_column", refColumn);+ result.add(item);+ }+ } catch (SQLException | AbstractMethodError | UnsupportedOperationException ignored) {+ // Foreign keys are optional detail; generic DDL must still succeed.+ }+ return result;+ }+private static JsonNode hive2ShowCreateObjectSource(Connection conn,String database,diff --git a/plugins/jdbc/src/main/java/app/dbx/jdbc/GenericJdbcDdlBuilder.java b/plugins/jdbc/src/main/java/app/dbx/jdbc/GenericJdbcDdlBuilder.javanew file mode 100644index 0000000000..f76a4abec9--- /dev/null+++ b/plugins/jdbc/src/main/java/app/dbx/jdbc/GenericJdbcDdlBuilder.java@@ -0,0 +1,236 @@+package app.dbx.jdbc;++import com.fasterxml.jackson.databind.JsonNode;++import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.LinkedHashSet;+import java.util.List;+import java.util.Map;+import java.util.Set;++/**+ * Renders a CREATE TABLE statement from the plugin's generic JDBC metadata+ * nodes. Used for external drivers that expose no vendor DDL statement, where+ * {@code DatabaseMetaData} is the only portable metadata source. Identifiers+ * are double-quoted per the SQL standard, matching the agent-side DdlBuilder.+ */+final class GenericJdbcDdlBuilder {++ private GenericJdbcDdlBuilder() {+ }++ static String buildTableDdl(String schema, String table, JsonNode columns, JsonNode indexes, JsonNode foreignKeys) {+ String tableRef = qualifiedName(schema, table);+ List<String> columnLines = new ArrayList<>();+ for (JsonNode column : columns) {+ String name = column.path("name").asText("");+ if (!name.isBlank()) {+ columnLines.add(columnLine(column, name));+ }+ }++ Set<String> primaryKeys = primaryKeysFromIndexes(indexes);+ if (primaryKeys.isEmpty()) {+ primaryKeys = primaryKeysFromColumnFlags(columns);+ }+ if (!primaryKeys.isEmpty()) {+ columnLines.add(" PRIMARY KEY (" + joinQuoted(primaryKeys) + ")");+ }++ List<ForeignKeyGroup> foreignKeyGroups = groupForeignKeys(foreignKeys);+ for (ForeignKeyGroup group : foreignKeyGroups) {+ String constraint = notBlank(group.name) ? "CONSTRAINT " + quoteIdent(group.name) + " " : "";+ columnLines.add(+ " " + constraint+ + "FOREIGN KEY (" + joinQuoted(group.columns) + ") "+ + "REFERENCES " + quoteIdent(group.refTable)+ + " (" + joinQuoted(group.refColumns) + ")"+ );+ }+ Set<String> foreignKeyColumnSets = new LinkedHashSet<>();+ for (ForeignKeyGroup group : foreignKeyGroups) {+ foreignKeyColumnSets.add(String.join("\u0000", group.columns));+ }++ StringBuilder ddl = new StringBuilder();+ ddl.append("CREATE TABLE ").append(tableRef).append(" (\n");+ ddl.append(String.join(",\n", columnLines));+ ddl.append("\n);\n");++ for (JsonNode index : indexes) {+ if (index.path("is_primary").asBoolean()) {+ continue;+ }+ String name = index.path("name").asText("");+ List<String> indexColumns = textValues(index.path("columns"));+ if (name.isBlank() || indexColumns.isEmpty()) {+ continue;+ }+ if (!index.path("is_unique").asBoolean() && foreignKeyColumnSets.contains(String.join("\u0000", indexColumns))) {+ // Many engines auto-create this index for the FOREIGN KEY+ // constraint itself; re-creating it would collide on restore.+ continue;+ }+ String unique = index.path("is_unique").asBoolean() ? "UNIQUE " : "";+ ddl.append("\nCREATE ").append(unique).append("INDEX ").append(quoteIdent(name));+ ddl.append(" ON ").append(tableRef);+ ddl.append(" (").append(String.join(", ", quoteAll(indexColumns))).append(");\n");+ }++ return ddl.toString();+ }++ private static String columnLine(JsonNode column, String name) {+ StringBuilder line = new StringBuilder(" ").append(quoteIdent(name));+ String type = column.path("data_type").asText("");+ if (!type.isBlank()) {+ line.append(" ").append(typeWithLength(column, type));+ }+ if (!column.path("is_nullable").asBoolean(true)) {+ line.append(" NOT NULL");+ }+ String defaultValue = column.path("column_default").asText("");+ if (!defaultValue.isBlank()) {+ line.append(" DEFAULT ").append(defaultValue);+ }+ return line.toString();+ }++ private static String typeWithLength(JsonNode column, String type) {+ String normalized = type.toLowerCase(java.util.Locale.ROOT);+ Integer characterLength = nullableInt(column, "character_maximum_length");+ if (isCharacterType(normalized) && characterLength != null && characterLength > 0) {+ return type + "(" + characterLength + ")";+ }+ Integer precision = nullableInt(column, "numeric_precision");+ if (isNumericType(normalized) && precision != null) {+ Integer scale = nullableInt(column, "numeric_scale");+ return scale != null ? type + "(" + precision + ", " + scale + ")" : type + "(" + precision + ")";+ }+ return type;+ }++ private static boolean isCharacterType(String normalized) {+ return "character varying".equals(normalized)+ || "varchar".equals(normalized)+ || "nvarchar".equals(normalized)+ || "char".equals(normalized)+ || "nchar".equals(normalized)+ || "character".equals(normalized);+ }++ private static boolean isNumericType(String normalized) {+ return "numeric".equals(normalized) || "decimal".equals(normalized);+ }++ private static Set<String> primaryKeysFromIndexes(JsonNode indexes) {+ for (JsonNode index : indexes) {+ if (index.path("is_primary").asBoolean()) {+ Set<String> columns = new LinkedHashSet<>(textValues(index.path("columns")));+ if (!columns.isEmpty()) {+ return columns;+ }+ }+ }+ return Set.of();+ }++ private static Set<String> primaryKeysFromColumnFlags(JsonNode columns) {+ Set<String> primaryKeys = new LinkedHashSet<>();+ for (JsonNode column : columns) {+ if (column.path("is_primary_key").asBoolean()) {+ String name = column.path("name").asText("");+ if (!name.isBlank()) {+ primaryKeys.add(name);+ }+ }+ }+ return primaryKeys;+ }++ private static List<ForeignKeyGroup> groupForeignKeys(JsonNode foreignKeys) {+ List<ForeignKeyGroup> ordered = new ArrayList<>();+ Map<String, ForeignKeyGroup> namedGroups = new LinkedHashMap<>();+ for (JsonNode foreignKey : foreignKeys) {+ String name = foreignKey.path("name").asText("");+ String refTable = foreignKey.path("ref_table").asText("");+ String column = foreignKey.path("column").asText("");+ String refColumn = foreignKey.path("ref_column").asText("");+ if (column.isBlank() || refTable.isBlank() || refColumn.isBlank()) {+ continue;+ }+ ForeignKeyGroup group = null;+ if (notBlank(name)) {+ group = namedGroups.get(name + "\u0000" + refTable);+ }+ if (group == null) {+ group = new ForeignKeyGroup(name, refTable);+ ordered.add(group);+ if (notBlank(name)) {+ namedGroups.put(name + "\u0000" + refTable, group);+ }+ }+ group.columns.add(column);+ group.refColumns.add(refColumn);+ }+ return ordered;+ }++ private static final class ForeignKeyGroup {+ private final String name;+ private final String refTable;+ private final List<String> columns = new ArrayList<>();+ private final List<String> refColumns = new ArrayList<>();++ private ForeignKeyGroup(String name, String refTable) {+ this.name = name;+ this.refTable = refTable;+ }+ }++ private static String qualifiedName(String schema, String name) {+ if (!notBlank(schema)) {+ return quoteIdent(name);+ }+ return quoteIdent(schema) + "." + quoteIdent(name);+ }++ private static String quoteIdent(String identifier) {+ return "\"" + identifier.replace("\"", "\"\"") + "\"";+ }++ private static String joinQuoted(Iterable<String> values) {+ return String.join(", ", quoteAll(values));+ }++ private static List<String> quoteAll(Iterable<String> values) {+ List<String> quoted = new ArrayList<>();+ for (String value : values) {+ quoted.add(quoteIdent(value));+ }+ return quoted;+ }++ private static List<String> textValues(JsonNode array) {+ List<String> values = new ArrayList<>();+ if (array.isArray()) {+ for (JsonNode value : array) {+ String text = value.asText("");+ if (!text.isBlank()) {+ values.add(text);+ }+ }+ }+ return values;+ }++ private static Integer nullableInt(JsonNode node, String field) {+ JsonNode value = node.path(field);+ return value.isMissingNode() || value.isNull() ? null : value.asInt();+ }++ private static boolean notBlank(String value) {+ return value != null && !value.trim().isEmpty();+ }+}diff --git a/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java b/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.javaindex f764d5fc15..e391b5b139 100644--- a/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java+++ b/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java@@ -5132,4 +5132,92 @@ final class DbxJdbcPluginTest {String once = DbxJdbcPlugin.enrichDriverHint(connection, "Unsupported charset: ZHS16GBK");assertEquals(once, DbxJdbcPlugin.enrichDriverHint(connection, once));}++ @Test+ void getObjectSourceBuildsExecutableTableDdlForPlainJdbcDrivers() throws Exception {+ String sourceDb = "jdbc:h2:mem:dbx_ddl_src;DB_CLOSE_DELAY=-1";+ try (Statement st = DriverManager.getConnection(sourceDb, "sa", "").createStatement()) {+ st.execute("CREATE TABLE \"dbx_ddl_parent\"(id BIGINT NOT NULL, CONSTRAINT pk_ddl_parent PRIMARY KEY(id))");+ st.execute("CREATE TABLE \"dbx_ddl_child\"("+ + "id BIGINT NOT NULL, name VARCHAR(50) NOT NULL DEFAULT 'x', parent_id BIGINT, "+ + "CONSTRAINT pk_ddl_child PRIMARY KEY(id), "+ + "CONSTRAINT fk_ddl_child FOREIGN KEY(parent_id) REFERENCES \"dbx_ddl_parent\"(id))");+ st.execute("CREATE UNIQUE INDEX \"uq_ddl_child_name\" ON \"dbx_ddl_child\"(name)");+ }++ JsonNode response = request("getObjectSource", """+ {+ "connection": { "connection_string": "%s", "username": "sa", "connect_timeout_secs": 30 },+ "name": "dbx_ddl_child",+ "object_type": "TABLE"+ }+ """.formatted(sourceDb));++ assertFalse(response.has("error"), response.toString());+ JsonNode result = response.path("result");+ assertEquals("TABLE", result.path("object_type").asText());+ String source = result.path("source").asText();+ assertTrue(source.startsWith("CREATE TABLE "), source);+ assertTrue(source.contains("PRIMARY KEY"), source);+ assertTrue(source.contains("NOT NULL"), source);+ assertTrue(source.contains("DEFAULT"), source);+ assertTrue(source.contains("FOREIGN KEY"), source);+ assertTrue(source.contains("REFERENCES"), source);+ assertTrue(source.contains("CREATE UNIQUE INDEX"), source);++ // The generated DDL must be executable: rebuild the child table in a+ // fresh database that only has the parent, then verify the rebuilt+ // structure matches the original (columns, PK, FK, unique index).+ String targetUrl = "jdbc:h2:mem:dbx_ddl_tgt;DB_CLOSE_DELAY=-1";+ try (Statement st = DriverManager.getConnection(targetUrl, "sa", "").createStatement()) {+ st.execute("CREATE TABLE \"dbx_ddl_parent\"(id BIGINT NOT NULL, CONSTRAINT pk_ddl_parent PRIMARY KEY(id))");+ for (String statement : source.split(";")) {+ if (!statement.isBlank()) {+ st.execute(statement);+ }+ }+ }+ try (Statement st = DriverManager.getConnection(targetUrl, "sa", "").createStatement();+ ResultSet rs = st.executeQuery("""+ SELECT+ (SELECT COUNT(*) FROM information_schema.columns+ WHERE table_name = 'dbx_ddl_child') AS column_count,+ (SELECT COUNT(*) FROM information_schema.table_constraints+ WHERE table_name = 'dbx_ddl_child' AND constraint_type = 'PRIMARY KEY') AS pk_count,+ (SELECT COUNT(*) FROM information_schema.table_constraints+ WHERE table_name = 'dbx_ddl_child' AND constraint_type = 'FOREIGN KEY') AS fk_count,+ (SELECT COUNT(*) FROM information_schema.indexes+ WHERE table_name = 'dbx_ddl_child' AND index_name = 'uq_ddl_child_name') AS uq_index_count+ """)) {+ assertTrue(rs.next());+ assertEquals(3, rs.getInt("column_count"));+ assertEquals(1, rs.getInt("pk_count"));+ assertEquals(1, rs.getInt("fk_count"));+ assertEquals(1, rs.getInt("uq_index_count"));+ }++ request("close", """+ { "connection": { "connection_string": "%s", "username": "sa" } }+ """.formatted(sourceDb));+ request("close", """+ { "connection": { "connection_string": "%s", "username": "sa" } }+ """.formatted(targetUrl));+ }++ @Test+ void getObjectSourceKeepsUnsupportedObjectTypesOnPlainJdbcDrivers() throws Exception {+ JsonNode response = request("getObjectSource", """+ {+ "connection": %s,+ "name": "some_view",+ "object_type": "VIEW"+ }+ """.formatted(CONNECTION));++ assertTrue(response.has("error"), response.toString());+ assertEquals(+ "Object source is not supported by this JDBC driver",+ response.path("error").path("message").asText()+ );+ }}