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): support GaussDB 100 (Zenith) metadata
Miklos Liu6ffe155d8316
diff --git a/apps/desktop/src/components/sidebar/ConnectionTree.vue b/apps/desktop/src/components/sidebar/ConnectionTree.vueindex 5e8ef06ab7..cbcbba67a7 100644--- a/apps/desktop/src/components/sidebar/ConnectionTree.vue+++ b/apps/desktop/src/components/sidebar/ConnectionTree.vue@@ -34,7 +34,7 @@ import { useSidebarRemoteSearch } from "@/composables/useSidebarRemoteSearch";import { collectSidebarRemoteSearchResults, mergeSidebarRemoteSearchResults, type SidebarRemoteSearchResult } from "@/lib/sidebar/sidebarRemoteSearch";import { isCancelSearchShortcut, isCopySidebarSelectionShortcut, isDisconnectSidebarConnectionShortcut, isEditSidebarConnectionShortcut, isEditSidebarTableStructureShortcut, isPasteSidebarSelectionShortcut, isRefreshDataShortcut, isViewTableDdlShortcut } from "@/lib/editor/keyboardShortcuts";import { sidebarNodeSupportsDdlView } from "@/lib/sidebar/sidebarTreeDdlShortcut";-import { hasTreeNodeDatabaseContext } from "@/lib/sidebar/treeNodeContext";+import { DEFAULT_DATABASE_TREE_LABEL, hasTreeNodeDatabaseContext } from "@/lib/sidebar/treeNodeContext";import { objectSourceTargetForTreeNode } from "@/lib/sidebar/treeNodeClick";import { supportsTypeObjectSource } from "@/lib/database/databaseObjectCapabilities";import { copyToClipboard } from "@/lib/common/clipboard";@@ -3068,7 +3068,7 @@ defineExpose({v-if="sidebarVisibleSchemasTarget?.connectionId && sidebarVisibleSchemasTarget.database != null"v-model:open="sidebarVisibleSchemasOpen":connection-id="sidebarVisibleSchemasTarget.connectionId"- :connection-name="sidebarVisibleSchemasTarget.label"+ :connection-name="sidebarVisibleSchemasTarget.label === DEFAULT_DATABASE_TREE_LABEL ? t(DEFAULT_DATABASE_TREE_LABEL) : sidebarVisibleSchemasTarget.label":database="sidebarVisibleSchemasTarget.database"/>diff --git a/apps/desktop/src/stores/__tests__/connectionStore.metadataLoading.spec.ts b/apps/desktop/src/stores/__tests__/connectionStore.metadataLoading.spec.tsindex 2af5d86c5a..04b049c60d 100644--- a/apps/desktop/src/stores/__tests__/connectionStore.metadataLoading.spec.ts+++ b/apps/desktop/src/stores/__tests__/connectionStore.metadataLoading.spec.ts@@ -4847,4 +4847,67 @@ describe("connectionStore metadata loading", () => {const labels = (tablesGroup.children ?? []).filter((child) => child.type === "table").map((child) => child.label);expect(labels).toContain("t_0201");});++ it("expands the catalogless default database on open and refreshes it after saving a schema filter", async () => {+ const listDatabases = vi.fn().mockResolvedValue([]);+ const listSchemaInfos = vi.fn().mockResolvedValue([{ name: "APP_USER" }, { name: "APP_USER_ARCHIVE" }, { name: "SYS" }]);++ vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));+ vi.doMock("@/lib/backend/api", () => ({+ checkConnectionHealth: vi.fn().mockResolvedValue(undefined),+ deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),+ listDatabases,+ listInstalledAgents: vi.fn().mockResolvedValue([]),+ listObjects: vi.fn().mockResolvedValue([]),+ listSchemaInfos,+ listTables: vi.fn().mockResolvedValue([]),+ loadSchemaCache: vi.fn().mockResolvedValue(null),+ saveSchemaCache: vi.fn().mockResolvedValue(undefined),+ saveConnections: vi.fn().mockResolvedValue(undefined),+ saveSidebarLayout: vi.fn().mockResolvedValue(undefined),+ }));++ const { useConnectionStore } = await import("@/stores/connectionStore");+ const store = useConnectionStore();+ // A Zenith (GaussDB 100) server through generic JDBC: no catalogs, users are schemas.+ const connection = {+ ...genericJdbcConnection(),+ id: "zenith-1",+ name: "Zenith",+ database: "",+ connection_string: "jdbc:zenith:@127.0.0.1:1888",+ jdbc_driver_class: "com.huawei.gauss.jdbc.ZenithDriver",+ } as ConnectionConfig;+ const connectionNode: TreeNode = { id: connection.id, label: connection.name, type: "connection", connectionId: connection.id, isExpanded: true, children: [] };+ store.connections = [connection];+ store.connectedIds.add(connection.id);+ store.treeNodes = [connectionNode];+ store.sidebarLayout = { groups: [], order: [{ type: "connection", id: connection.id }] };++ await store.loadDatabases(connection.id, { force: true });+ // Saving the filter rebuilds the tree, so always resolve the live node.+ const findById = (nodes: TreeNode[], id: string): TreeNode | undefined => {+ for (const node of nodes) {+ if (node.id === id) return node;+ const found = findById(node.children ?? [], id);+ if (found) return found;+ }+ return undefined;+ };+ const defaultDatabase = () => findById(store.treeNodes, "zenith-1:")!;+ const schemaLabels = () =>+ defaultDatabase()+ .children?.filter((node) => node.type === "schema")+ .map((node) => node.label);+ // Opening the connection expands the placeholder default database so the schemas show at once.+ expect(defaultDatabase().id).toBe("zenith-1:");+ expect(defaultDatabase().isExpanded).toBe(true);+ expect(schemaLabels()).toEqual(["APP_USER", "APP_USER_ARCHIVE", "SYS"]);++ await store.setVisibleSchemas(connection.id, "", ["APP_USER"]);++ // The saved filter must show without a manual refresh of the connection.+ expect(store.getConfig(connection.id)?.visible_schemas).toEqual({ "": ["APP_USER"] });+ expect(schemaLabels()).toEqual(["APP_USER"]);+ });});diff --git a/apps/desktop/src/stores/connectionStore.ts b/apps/desktop/src/stores/connectionStore.tsindex 4db5b30ea4..b37caab47e 100644--- a/apps/desktop/src/stores/connectionStore.ts+++ b/apps/desktop/src/stores/connectionStore.ts@@ -4903,6 +4903,23 @@ export const useConnectionStore = defineStore("connection", () => {rebuildTreeNodes();}+ // Catalog-less generic JDBC servers (e.g. Zenith / GaussDB 100) only report the+ // placeholder default database, so a collapsed node would hide every schema.+ // Open it right away so the schema list shows when the connection is opened.+ async function expandCatalogLessJdbcDefaultDatabase(connectionNode: TreeNode | null, config: ConnectionConfig | undefined) {+ if (!connectionNode || config?.db_type !== "jdbc" || !connectionShouldDiscoverJdbcSchemas(config)) return;+ const databaseNodes = (connectionNode.children ?? []).filter((child) => child.type === "database");+ if (databaseNodes.length !== 1 || databaseNodes[0].database !== "") return;+ const defaultNodeId = databaseNodes[0].id;+ try {+ await loadTreeNodeChildren(databaseNodes[0]);+ } catch {+ // Schema loading records its own error on the node; keep the database list usable.+ }+ const liveNode = findNode(treeNodes.value, defaultNodeId);+ if (liveNode) liveNode.isExpanded = true;+ }+async function reloadSchemaChildren(connectionId: string, database?: string) {const config = getConfig(connectionId);if (!config) return;@@ -4911,12 +4928,12 @@ export const useConnectionStore = defineStore("connection", () => {clearLoadedChildrenCache(`${connectionId}:${db}`);await loadDatabases(connectionId, { force: true });// After saving schema filter, force-refresh database node's schema children- // to avoid stale children from previously expanded nodes- if (db) {- const dbNode = findNode(treeNodes.value, `${connectionId}:${db}`);- if (dbNode) {- await loadTreeNodeChildren(dbNode, { force: true });- }+ // to avoid stale children from previously expanded nodes. Catalog-less JDBC+ // connections (Oracle/Zenith via generic JDBC) keep their schemas under the+ // default database node, whose id ends with an empty database name.+ const dbNode = findNode(treeNodes.value, `${connectionId}:${db}`);+ if (dbNode) {+ await loadTreeNodeChildren(dbNode, { force: true });}}@@ -5991,6 +6008,7 @@ export const useConnectionStore = defineStore("connection", () => {if (cached.hit) {if (cached.isStale) refreshStaleTreeNode(node);else scheduleMissingPrimaryVisibleObjectNamesRefresh(connectionId, config, options);+ await expandCatalogLessJdbcDefaultDatabase(treeNodeLoadTarget(load), config);return;}}@@ -6038,6 +6056,7 @@ export const useConnectionStore = defineStore("connection", () => {);setChildren(targetNode, children, { trustEmptyConnectionChildren: databases.length > 0 && visibleNames.length === 0 });await savePersistedConnectionTreeChildren(cacheKey, targetNode.children || children);+ await expandCatalogLessJdbcDefaultDatabase(treeNodeLoadTarget(load), config);}}const liveNode = treeNodeLoadTarget(load);diff --git a/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.javaindex d667a80c69..b9a51858dc 100644--- a/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java+++ b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java@@ -2568,7 +2568,7 @@ public final class DbxJdbcPlugin {ArrayNode result = MAPPER.createArrayNode();Connection conn = openConnection(connection);JdbcDriverQuirks quirks = driverQuirks(connection);- if (quirks.useOracleMetadata()) {+ if (quirks.useOracleMetadata() || isZenithConnection(connection, conn)) {return result;}DatabaseMetaData metadata = conn.getMetaData();@@ -2647,6 +2647,9 @@ public final class DbxJdbcPlugin {if (quirks.useOracleMetadata()) {return oracleListSchemas(conn);}+ if (isZenithConnection(connection, conn)) {+ return zenithListSchemas(conn);+ }DatabaseMetaData meta = conn.getMetaData();if (quirks.caseInsensitiveSchemaMetadata()) {try (ResultSet rs = meta.getSchemas(catalog, null)) {@@ -2727,6 +2730,17 @@ public final class DbxJdbcPlugin {if (usePrestoInformationSchemaTables(connection)) {return prestoListTables(conn, database, schema, filter, limit, offset, objectTypes);}+ if (isZenithConnection(connection, conn)) {+ return filterMetadataNodes(+ (ArrayNode) zenithListTables(conn, zenithEffectiveSchema(conn, schema), false, null),+ filter,+ limit,+ offset,+ objectTypes,+ "table_type",+ true+ );+ }if (isKingbaseUrl(optionalText(connection, "connection_string"))) {return filterMetadataNodes((ArrayNode) kingbaseListTables(conn, schema, false),@@ -2785,6 +2799,17 @@ public final class DbxJdbcPlugin {if (usePrestoInformationSchemaTables(connection)) {return prestoListObjects(conn, database, schema, filter, limit, offset, objectTypes);}+ if (isZenithConnection(connection, conn)) {+ return filterMetadataNodes(+ (ArrayNode) zenithListObjects(conn, zenithEffectiveSchema(conn, schema), schema),+ filter,+ limit,+ offset,+ objectTypes,+ "object_type",+ false+ );+ }boolean kingbase = isKingbaseUrl(optionalText(connection, "connection_string"));if (kingbase) {result.addAll((ArrayNode) kingbaseListTables(conn, schema, true));@@ -3041,6 +3066,10 @@ public final class DbxJdbcPlugin {String resolvedTable = exactIdentity ? table : oracleResolveTable(conn, owner, table);return oracleListIndexes(conn, owner, resolvedTable == null ? table : resolvedTable, exactIdentity);}+ if (isZenithConnection(connection, conn)) {+ String owner = zenithEffectiveSchema(conn, schema);+ return zenithListIndexes(conn, owner, zenithResolveTable(conn, owner, table));+ }DatabaseMetaData meta = conn.getMetaData();String catalog = metadataCatalog(database, quirks);@@ -3194,6 +3223,9 @@ public final class DbxJdbcPlugin {if (driverQuirks(connection).useOracleMetadata()) {return oracleGetColumns(conn, exactIdentity ? schema : oracleEffectiveSchema(conn, schema), table, exactIdentity);}+ if (isZenithConnection(connection, conn)) {+ return zenithGetColumns(conn, zenithEffectiveSchema(conn, schema), table);+ }if (isKingbaseUrl(optionalText(connection, "connection_string"))) {return kingbaseGetColumns(conn, schema, table);}@@ -3931,6 +3963,372 @@ public final class DbxJdbcPlugin {return urlMatchesPrefix(url, "jdbc:kingbase");}+ // --- Zenith (GaussDB 100) metadata methods ---+ //+ // The Zenith driver's DatabaseMetaData queries Oracle's ALL_* views, which+ // Zenith does not have (its dictionary is DB_*/ADM_*/MY_*), so getSchemas(),+ // getTables(), getColumns() and getIndexInfo() all fail with GS-00843, and+ // getSchemas(String, String) / Connection.getSchema() are unimplemented.+ // Zenith has no catalogs: schema = user. Read the DB_* views directly.++ private static final String ZENITH_DRIVER_CLASS = "com.huawei.gauss.jdbc.ZenithDriver";++ static boolean isZenithConnection(JsonNode connection) {+ if (urlMatchesPrefix(optionalText(connection, "connection_string"), "jdbc:zenith:")) {+ return true;+ }+ String driverClass = optionalText(connection, "jdbc_driver_class");+ return driverClass != null && ZENITH_DRIVER_CLASS.equals(driverClass.trim());+ }++ private static boolean isZenithConnection(JsonNode connection, Connection conn) {+ if (isZenithConnection(connection)) {+ return true;+ }+ try {+ DatabaseMetaData meta = conn.getMetaData();+ String product = meta == null ? null : meta.getDatabaseProductName();+ return product != null && product.regionMatches(true, 0, "Zenith", 0, 6);+ } catch (SQLException | AbstractMethodError | UnsupportedOperationException ignored) {+ return false;+ }+ }++ private static String zenithEffectiveSchema(Connection conn, String schema) throws SQLException {+ if (schema != null && !schema.isBlank()) {+ return zenithResolveOwner(conn, schema);+ }+ try (Statement stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery("SELECT USER FROM DUAL")) {+ String current = rs.next() ? rs.getString(1) : null;+ if (current != null && !current.isBlank()) {+ return current;+ }+ } catch (SQLException ignored) {+ }+ String username = conn.getMetaData().getUserName();+ if (username == null || username.isBlank()) {+ // An empty owner would make every dictionary query silently return nothing.+ throw new SQLException("Unable to determine the current Zenith user; specify a schema explicitly");+ }+ return zenithResolveOwner(conn, username);+ }++ private static String zenithResolveOwner(Connection conn, String owner) throws SQLException {+ String sql = "SELECT USERNAME FROM DB_USERS WHERE USERNAME = ?";+ String exact = oracleFindIdentifier(conn, sql, owner);+ if (exact != null) {+ return exact;+ }+ exact = oracleFindIdentifier(conn, sql, owner.toUpperCase(Locale.ROOT));+ return exact == null ? owner : exact;+ }++ private static String zenithResolveTable(Connection conn, String owner, String table) throws SQLException {+ String sql = "SELECT OBJECT_NAME FROM DB_OBJECTS WHERE OWNER = ? AND OBJECT_NAME = ?";+ String exact = oracleFindIdentifier(conn, sql, owner, table);+ if (exact != null) {+ return exact;+ }+ exact = oracleFindIdentifier(conn, sql, owner, table.toUpperCase(Locale.ROOT));+ return exact == null ? table : exact;+ }++ private static JsonNode zenithListSchemas(Connection conn) throws SQLException {+ ArrayNode result = MAPPER.createArrayNode();+ try (Statement stmt = conn.createStatement();+ ResultSet rs = stmt.executeQuery("SELECT USERNAME FROM DB_USERS ORDER BY USERNAME")) {+ while (rs.next()) {+ String name = rs.getString(1);+ if (name != null && !name.isBlank()) {+ result.add(name);+ }+ }+ } catch (SQLException e) {+ // Without DB_USERS access the login user's own schema is still browsable.+ // If that fallback fails too, report the original DB_USERS error.+ try {+ result.add(zenithEffectiveSchema(conn, null));+ } catch (SQLException fallback) {+ e.addSuppressed(fallback);+ throw e;+ }+ }+ return result;+ }++ private static JsonNode zenithListTables(Connection conn, String owner, boolean objectNodes, String schemaLabel)+ throws SQLException {+ ArrayNode result = MAPPER.createArrayNode();+ String tableSql =+ "SELECT t.TABLE_NAME AS NAME, c.COMMENTS AS COMMENTS FROM DB_TABLES t " ++ "LEFT JOIN DB_TAB_COMMENTS c ON c.OWNER = t.OWNER AND c.TABLE_NAME = t.TABLE_NAME " ++ "WHERE t.OWNER = ? ORDER BY t.TABLE_NAME";+ String viewSql =+ "SELECT v.VIEW_NAME AS NAME, c.COMMENTS AS COMMENTS FROM DB_VIEWS v " ++ "LEFT JOIN DB_TAB_COMMENTS c ON c.OWNER = v.OWNER AND c.TABLE_NAME = v.VIEW_NAME " ++ "WHERE v.OWNER = ? ORDER BY v.VIEW_NAME";+ appendZenithTables(result, conn, tableSql, owner, "TABLE", objectNodes, schemaLabel);+ appendZenithTables(result, conn, viewSql, owner, "VIEW", objectNodes, schemaLabel);+ return result;+ }++ private static void appendZenithTables(+ ArrayNode result,+ Connection conn,+ String sql,+ String owner,+ String type,+ boolean objectNodes,+ String schemaLabel+ ) throws SQLException {+ try (PreparedStatement ps = conn.prepareStatement(sql)) {+ ps.setString(1, owner);+ try (ResultSet rs = ps.executeQuery()) {+ while (rs.next()) {+ ObjectNode item = MAPPER.createObjectNode();+ item.put("name", rs.getString("NAME"));+ item.put(objectNodes ? "object_type" : "table_type", type);+ if (objectNodes) {+ putNullable(item, "schema", schemaLabel);+ }+ putNullable(item, "comment", emptyToNull(rs.getString("COMMENTS")));+ result.add(item);+ }+ }+ }+ }++ private static JsonNode zenithListObjects(Connection conn, String owner, String schemaLabel) throws SQLException {+ ArrayNode result = (ArrayNode) zenithListTables(conn, owner, true, schemaLabel);+ // Procedures and functions live only in DB_PROCEDURES, not in DB_OBJECTS.+ appendZenithObjects(+ result,+ conn,+ "SELECT DISTINCT OBJECT_NAME, OBJECT_TYPE FROM DB_PROCEDURES " ++ "WHERE OWNER = ? AND OBJECT_TYPE IN ('PROCEDURE', 'FUNCTION') ORDER BY OBJECT_TYPE, OBJECT_NAME",+ owner,+ null,+ schemaLabel+ );+ appendZenithObjects(+ result,+ conn,+ "SELECT SEQUENCE_NAME FROM DB_SEQUENCES WHERE SEQUENCE_OWNER = ? ORDER BY SEQUENCE_NAME",+ owner,+ "SEQUENCE",+ schemaLabel+ );+ appendZenithObjects(+ result,+ conn,+ "SELECT SYNONYM_NAME FROM DB_SYNONYMS WHERE OWNER = ? ORDER BY SYNONYM_NAME",+ owner,+ "SYNONYM",+ schemaLabel+ );+ return result;+ }++ private static void appendZenithObjects(+ ArrayNode result,+ Connection conn,+ String sql,+ String owner,+ String objectType,+ String schemaLabel+ ) {+ try (PreparedStatement ps = conn.prepareStatement(sql)) {+ ps.setString(1, owner);+ try (ResultSet rs = ps.executeQuery()) {+ while (rs.next()) {+ ObjectNode item = MAPPER.createObjectNode();+ item.put("name", rs.getString(1));+ item.put("object_type", objectType == null ? rs.getString(2) : objectType);+ putNullable(item, "schema", schemaLabel);+ item.putNull("comment");+ result.add(item);+ }+ }+ } catch (SQLException ignored) {+ // Routines, sequences and synonyms are optional; they must not hide tables.+ }+ }++ private static JsonNode zenithGetColumns(Connection conn, String owner, String table) throws SQLException {+ ArrayNode result = MAPPER.createArrayNode();+ String resolvedTable = zenithResolveTable(conn, owner, table);+ Set<String> pks = zenithPrimaryKeys(conn, owner, resolvedTable);+ // The driver's getColumns() reports DATA_TYPE=0, shifts precision/scale and+ // drops comments and defaults, so the dictionary view is the only reliable source.+ String sql =+ "SELECT c.DATA_DEFAULT, c.COLUMN_NAME, c.DATA_TYPE, c.DATA_LENGTH, c.DATA_PRECISION, c.DATA_SCALE, " ++ "c.CHAR_LENGTH, c.NULLABLE, c.AUTO_INCREMENT, m.COMMENTS " ++ "FROM DB_TAB_COLUMNS c " ++ "LEFT JOIN DB_COL_COMMENTS m ON m.OWNER = c.OWNER AND m.TABLE_NAME = c.TABLE_NAME AND m.COLUMN_NAME = c.COLUMN_NAME " ++ "WHERE c.OWNER = ? AND c.TABLE_NAME = ? ORDER BY c.COLUMN_ID";+ try (PreparedStatement ps = conn.prepareStatement(sql)) {+ ps.setString(1, owner);+ ps.setString(2, resolvedTable);+ try (ResultSet rs = ps.executeQuery()) {+ while (rs.next()) {+ String dataDefault = rs.getString("DATA_DEFAULT");+ String name = rs.getString("COLUMN_NAME");+ String dataType = rs.getString("DATA_TYPE");+ ObjectNode item = columnNode(result, name);+ item.put("data_type", dataType);+ item.put("is_nullable", !"N".equalsIgnoreCase(rs.getString("NULLABLE")));+ putNullablePreferValue(item, "column_default", dataDefault == null ? null : dataDefault.trim());+ item.put("is_primary_key", pks.contains(name));+ if ("Y".equalsIgnoreCase(rs.getString("AUTO_INCREMENT"))) {+ item.put("extra", "auto_increment");+ } else {+ item.putNull("extra");+ }+ putNullablePreferValue(item, "comment", rs.getString("COMMENTS"));+ putNullableInt(item, "numeric_precision", rs.getObject("DATA_PRECISION"));+ putNullableInt(item, "numeric_scale", rs.getObject("DATA_SCALE"));+ putNullableInt(+ item,+ "character_maximum_length",+ zenithCharacterLength(dataType, rs.getObject("CHAR_LENGTH"), rs.getObject("DATA_LENGTH"))+ );+ }+ }+ }+ return result;+ }++ private static final Set<String> ZENITH_LENGTH_TYPES = Set.of(+ "CHAR", "NCHAR", "VARCHAR", "VARCHAR2", "NVARCHAR", "NVARCHAR2", "BINARY", "VARBINARY", "RAW"+ );++ static Object zenithCharacterLength(String dataType, Object charLength, Object dataLength) {+ if (charLength instanceof Number number && number.intValue() > 0) {+ return number;+ }+ // DATA_LENGTH is the storage size in bytes, which only means "length" for string/binary types.+ String type = dataType == null ? "" : dataType.trim().toUpperCase(Locale.ROOT);+ return ZENITH_LENGTH_TYPES.contains(type) ? dataLength : null;+ }++ private static Set<String> zenithPrimaryKeys(Connection conn, String owner, String table) {+ String sql = "SELECT COLUMNS FROM DB_INDEXES WHERE OWNER = ? AND TABLE_NAME = ? AND IS_PRIMARY = 'Y'";+ Set<String> keys = new LinkedHashSet<>();+ try (PreparedStatement ps = conn.prepareStatement(sql)) {+ ps.setString(1, owner);+ ps.setString(2, table);+ try (ResultSet rs = ps.executeQuery()) {+ while (rs.next()) {+ keys.addAll(splitZenithIndexColumns(rs.getString(1)));+ }+ }+ } catch (SQLException ignored) {+ // Primary-key flags are optional detail; the column list must still load.+ }+ return keys;+ }++ /** DB_INDEXES.COLUMNS is a ", "-separated column list, e.g. "ORDER_ID, REGION_ID, STATUS". */+ static List<String> splitZenithIndexColumns(String columns) {+ List<String> result = new ArrayList<>();+ if (columns == null) {+ return result;+ }+ for (String column : columns.split(",")) {+ String trimmed = column.trim();+ if (!trimmed.isEmpty()) {+ result.add(trimmed);+ }+ }+ return result;+ }++ private static JsonNode zenithListIndexes(Connection conn, String owner, String table) {+ // DB_IND_COLUMNS has no OWNER column; it joins on INDEX_OWNER.+ String sql =+ "SELECT i.INDEX_NAME, i.IS_PRIMARY, i.IS_UNIQUE, ic.COLUMN_NAME FROM DB_INDEXES i " ++ "JOIN DB_IND_COLUMNS ic ON ic.INDEX_OWNER = i.OWNER AND ic.INDEX_NAME = i.INDEX_NAME " ++ "WHERE i.OWNER = ? AND i.TABLE_NAME = ? ORDER BY i.INDEX_NAME, ic.COLUMN_POSITION";+ LinkedHashMap<String, ObjectNode> indexes = new LinkedHashMap<>();+ try (PreparedStatement ps = conn.prepareStatement(sql)) {+ ps.setString(1, owner);+ ps.setString(2, table);+ try (ResultSet rs = ps.executeQuery()) {+ while (rs.next()) {+ String name = rs.getString("INDEX_NAME");+ ObjectNode item = indexes.get(name);+ if (item == null) {+ item = indexNode(+ name,+ "Y".equalsIgnoreCase(rs.getString("IS_UNIQUE")),+ "Y".equalsIgnoreCase(rs.getString("IS_PRIMARY")),+ null+ );+ indexes.put(name, item);+ }+ String column = rs.getString("COLUMN_NAME");+ if (column != null && !column.isBlank()) {+ ((ArrayNode) item.path("columns")).add(column);+ }+ }+ }+ } catch (SQLException ignored) {+ // Index metadata is optional detail, matching the other index readers.+ indexes.clear();+ }+ ArrayNode result = MAPPER.createArrayNode();+ indexes.values().forEach(result::add);+ return result;+ }++ private static JsonNode zenithObjectSource(Connection conn, String owner, String name, String objectType)+ throws SQLException {+ String normalizedType = normalizeObjectType(objectType);+ String source;+ if ("VIEW".equals(normalizedType)) {+ String text = zenithSingleText(conn, "SELECT TEXT FROM DB_VIEWS WHERE OWNER = ? AND VIEW_NAME = ?", owner, name);+ source = "CREATE OR REPLACE VIEW " + zenithQuoteIdentifier(owner) + "." + zenithQuoteIdentifier(name) + " AS\n" + text;+ } else if ("PROCEDURE".equals(normalizedType) || "FUNCTION".equals(normalizedType)) {+ // DB_SOURCE.LINE is NULL on Zenith, so the routine body must come from DB_PROCEDURES.SOURCE.+ source = zenithSingleText(+ conn,+ "SELECT SOURCE FROM DB_PROCEDURES WHERE OWNER = ? AND OBJECT_NAME = ? AND OBJECT_TYPE = ?",+ owner,+ stripRoutineSignature(name),+ normalizedType+ );+ } else {+ throw new SQLException("Object source is not supported by this JDBC driver");+ }+ ObjectNode item = MAPPER.createObjectNode();+ item.put("name", name);+ item.put("object_type", objectType);+ putNullable(item, "schema", owner);+ item.put("source", source);+ // Read-only until the generated DDL has been verified against a live Zenith server.+ item.put("editable", false);+ return item;+ }++ private static String zenithSingleText(Connection conn, String sql, String... params) throws SQLException {+ try (PreparedStatement ps = conn.prepareStatement(sql)) {+ for (int i = 0; i < params.length; i++) {+ ps.setString(i + 1, params[i]);+ }+ try (ResultSet rs = ps.executeQuery()) {+ if (!rs.next()) {+ throw new SQLException("Object source not found");+ }+ String text = rs.getString(1);+ return text == null ? "" : text;+ }+ }+ }++ private static String zenithQuoteIdentifier(String identifier) {+ return "\"" + identifier.replace("\"", "\"\"") + "\"";+ }+private static boolean isSybaseConnection(JsonNode connection) {String url = optionalText(connection, "connection_string");if (urlMatchesPrefix(url, "jdbc:sybase:") || urlMatchesPrefix(url, "jdbc:jtds:sybase:")) {@@ -4826,6 +5224,10 @@ public final class DbxJdbcPlugin {return sybaseViewObjectSource(connection, conn, database, schema, name, objectType);}+ if (isZenithConnection(connection, conn) && !"TABLE".equals(normalizeObjectType(objectType))) {+ return zenithObjectSource(conn, zenithEffectiveSchema(conn, schema), name, objectType);+ }+if ("TABLE".equals(normalizeObjectType(objectType))) {return genericTableObjectSource(connection, database, schema, name);}diff --git a/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java b/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.javaindex 0524b94d3a..b3133cd756 100644--- a/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java+++ b/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java@@ -9,6 +9,7 @@ import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;import java.lang.reflect.Field;+import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.math.BigDecimal;@@ -45,6 +46,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertNotEquals;import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;final class DbxJdbcPluginTest {@@ -3850,6 +3852,233 @@ final class DbxJdbcPluginTest {}}+ @Test+ void zenithConnectionIsDetectedByUrlOrDriverClass() throws Exception {+ assertTrue(DbxJdbcPlugin.isZenithConnection(MAPPER.readTree("""+ { "connection_string": "JDBC:Zenith:@192.0.2.10:1888" }+ """)));+ assertTrue(DbxJdbcPlugin.isZenithConnection(MAPPER.readTree("""+ { "connection_string": "jdbc:wrapped:x", "jdbc_driver_class": " com.huawei.gauss.jdbc.ZenithDriver " }+ """)));+ assertFalse(DbxJdbcPlugin.isZenithConnection(MAPPER.readTree("""+ { "connection_string": "jdbc:oracle:thin:@//db:1521/ORCL" }+ """)));+ assertFalse(DbxJdbcPlugin.isZenithConnection(MAPPER.readTree("""+ { "connection_string": "jdbc:gaussdb://db:8000/postgres", "jdbc_driver_class": "com.huawei.gaussdb.jdbc.Driver" }+ """)));+ }++ @Test+ void zenithListsSchemasFromDbUsersAndDefaultsToLoginUser() throws Exception {+ Method listSchemas = DbxJdbcPlugin.class.getDeclaredMethod("zenithListSchemas", Connection.class);+ listSchemas.setAccessible(true);+ Method effectiveSchema = DbxJdbcPlugin.class.getDeclaredMethod("zenithEffectiveSchema", Connection.class, String.class);+ effectiveSchema.setAccessible(true);++ try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:dbx_zenith_users;DB_CLOSE_DELAY=-1", "sa", "")) {+ conn.createStatement().execute("CREATE TABLE DB_USERS (USERNAME VARCHAR(64))");+ conn.createStatement().execute("INSERT INTO DB_USERS(USERNAME) VALUES ('SYS'), ('APP_USER'), ('APP_USER_ARCHIVE')");++ JsonNode schemas = (JsonNode) listSchemas.invoke(null, conn);+ assertEquals(List.of("APP_USER", "APP_USER_ARCHIVE", "SYS"), MAPPER.convertValue(schemas, List.class));+ assertEquals("APP_USER", effectiveSchema.invoke(null, conn, "app_user"));+ // Connection.getSchema() is unimplemented by the driver; the login user comes from SELECT USER FROM DUAL.+ assertEquals("SA", effectiveSchema.invoke(null, conn, ""));+ }+ }++ @Test+ void zenithListSchemasFallsBackToLoginUserWithoutDbUsers() throws Exception {+ Method listSchemas = DbxJdbcPlugin.class.getDeclaredMethod("zenithListSchemas", Connection.class);+ listSchemas.setAccessible(true);++ try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:dbx_zenith_no_users;DB_CLOSE_DELAY=-1", "sa", "")) {+ JsonNode schemas = (JsonNode) listSchemas.invoke(null, conn);+ assertEquals(List.of("SA"), MAPPER.convertValue(schemas, List.class));+ }+ }++ @Test+ void zenithSchemaFallbackRejectsBlankUserAndKeepsOriginalError() throws Exception {+ Method listSchemas = DbxJdbcPlugin.class.getDeclaredMethod("zenithListSchemas", Connection.class);+ listSchemas.setAccessible(true);+ Method effectiveSchema = DbxJdbcPlugin.class.getDeclaredMethod("zenithEffectiveSchema", Connection.class, String.class);+ effectiveSchema.setAccessible(true);+ Connection conn = zenithFailingConnection("");++ InvocationTargetException blank = assertThrows(+ InvocationTargetException.class,+ () -> effectiveSchema.invoke(null, conn, null)+ );+ assertTrue(blank.getCause().getMessage().contains("Unable to determine the current Zenith user"));++ InvocationTargetException listed = assertThrows(InvocationTargetException.class, () -> listSchemas.invoke(null, conn));+ SQLException original = (SQLException) listed.getCause();+ assertTrue(original.getMessage().contains("DB_USERS"));+ assertEquals(1, original.getSuppressed().length);+ assertTrue(original.getSuppressed()[0].getMessage().contains("Unable to determine the current Zenith user"));+ }++ @Test+ void zenithListObjectsReadsDbViewsPerSchema() throws Exception {+ Method method = DbxJdbcPlugin.class.getDeclaredMethod("zenithListObjects", Connection.class, String.class, String.class);+ method.setAccessible(true);++ try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:dbx_zenith_objects;DB_CLOSE_DELAY=-1", "sa", "")) {+ conn.createStatement().execute("CREATE TABLE DB_TABLES (OWNER VARCHAR(64), TABLE_NAME VARCHAR(64))");+ conn.createStatement().execute("CREATE TABLE DB_VIEWS (OWNER VARCHAR(64), VIEW_NAME VARCHAR(64), TEXT VARCHAR(256))");+ conn.createStatement().execute(+ "CREATE TABLE DB_TAB_COMMENTS (OWNER VARCHAR(64), TABLE_NAME VARCHAR(64), TABLE_TYPE VARCHAR(16), COMMENTS VARCHAR(128))"+ );+ conn.createStatement().execute(+ "CREATE TABLE DB_PROCEDURES (OWNER VARCHAR(64), OBJECT_NAME VARCHAR(64), PROCEDURE_NAME VARCHAR(64), OBJECT_TYPE VARCHAR(16), SOURCE VARCHAR(256))"+ );+ conn.createStatement().execute("CREATE TABLE DB_SEQUENCES (SEQUENCE_OWNER VARCHAR(64), SEQUENCE_NAME VARCHAR(64))");+ conn.createStatement().execute(+ "INSERT INTO DB_TABLES VALUES ('APP_USER', 'ORDERS'), ('OTHER', 'NOT_MINE')"+ );+ conn.createStatement().execute("INSERT INTO DB_VIEWS VALUES ('APP_USER', 'V_ORDERS', 'SELECT 1 FROM DUAL')");+ conn.createStatement().execute("INSERT INTO DB_TAB_COMMENTS VALUES ('APP_USER', 'ORDERS', 'TABLE', '订单')");+ conn.createStatement().execute(+ "INSERT INTO DB_PROCEDURES VALUES " ++ "('APP_USER', 'P_SYNC', NULL, 'PROCEDURE', 'src'), ('APP_USER', 'P_SYNC', NULL, 'PROCEDURE', 'src'), " ++ "('APP_USER', 'F_CALC', NULL, 'FUNCTION', 'src'), ('APP_USER', 'T_SPEC', NULL, 'TYPE SPEC', 'src')"+ );+ conn.createStatement().execute("INSERT INTO DB_SEQUENCES VALUES ('APP_USER', 'SEQ_ORDERS')");++ // DB_SYNONYMS is absent here: optional object kinds must not hide tables.+ JsonNode result = (JsonNode) method.invoke(null, conn, "APP_USER", "APP_USER");+ List<String> entries = new ArrayList<>();+ for (JsonNode node : result) {+ entries.add(node.path("object_type").asText() + ":" + node.path("name").asText());+ assertEquals("APP_USER", node.path("schema").asText());+ }+ assertEquals(+ List.of("TABLE:ORDERS", "VIEW:V_ORDERS", "FUNCTION:F_CALC", "PROCEDURE:P_SYNC", "SEQUENCE:SEQ_ORDERS"),+ entries+ );+ assertEquals("订单", result.path(0).path("comment").asText());+ }+ }++ @Test+ void zenithGetColumnsAndIndexesUseDictionaryViews() throws Exception {+ Method getColumns = DbxJdbcPlugin.class.getDeclaredMethod("zenithGetColumns", Connection.class, String.class, String.class);+ getColumns.setAccessible(true);+ Method listIndexes = DbxJdbcPlugin.class.getDeclaredMethod("zenithListIndexes", Connection.class, String.class, String.class);+ listIndexes.setAccessible(true);++ try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:dbx_zenith_columns;DB_CLOSE_DELAY=-1", "sa", "")) {+ conn.createStatement().execute("CREATE TABLE DB_OBJECTS (OWNER VARCHAR(64), OBJECT_NAME VARCHAR(64), OBJECT_TYPE VARCHAR(16))");+ conn.createStatement().execute(+ "CREATE TABLE DB_TAB_COLUMNS (OWNER VARCHAR(64), TABLE_NAME VARCHAR(64), COLUMN_NAME VARCHAR(64), " ++ "DATA_TYPE VARCHAR(32), DATA_LENGTH INT, DATA_PRECISION INT, DATA_SCALE INT, CHAR_LENGTH INT, " ++ "NULLABLE VARCHAR(1), COLUMN_ID INT, DATA_DEFAULT VARCHAR(64), AUTO_INCREMENT VARCHAR(1))"+ );+ conn.createStatement().execute(+ "CREATE TABLE DB_COL_COMMENTS (OWNER VARCHAR(64), TABLE_NAME VARCHAR(64), COLUMN_NAME VARCHAR(64), COMMENTS VARCHAR(128))"+ );+ conn.createStatement().execute(+ "CREATE TABLE DB_INDEXES (OWNER VARCHAR(64), TABLE_NAME VARCHAR(64), INDEX_NAME VARCHAR(64), " ++ "IS_PRIMARY VARCHAR(1), IS_UNIQUE VARCHAR(1), COLUMNS VARCHAR(256))"+ );+ // DB_IND_COLUMNS has no OWNER column on Zenith.+ conn.createStatement().execute(+ "CREATE TABLE DB_IND_COLUMNS (INDEX_OWNER VARCHAR(64), INDEX_NAME VARCHAR(64), TABLE_OWNER VARCHAR(64), " ++ "TABLE_NAME VARCHAR(64), COLUMN_NAME VARCHAR(64), COLUMN_POSITION INT)"+ );+ conn.createStatement().execute("INSERT INTO DB_OBJECTS VALUES ('APP_USER', 'ORDERS', 'TABLE')");+ // COLUMN_ID starts at 0 on Zenith.+ conn.createStatement().execute(+ "INSERT INTO DB_TAB_COLUMNS VALUES " ++ "('APP_USER', 'ORDERS', 'ORDER_ID', 'NUMBER', 22, 10, 0, 0, 'N', 0, NULL, 'N'), " ++ "('APP_USER', 'ORDERS', 'REGION_ID', 'BINARY_INTEGER', 4, NULL, NULL, 0, 'N', 1, NULL, 'N'), " ++ "('APP_USER', 'ORDERS', 'ORDER_NAME', 'VARCHAR', 400, NULL, NULL, 0, 'Y', 2, '''none'' ', 'N'), " ++ "('APP_USER', 'ORDERS', 'SEQ_NO', 'BIGINT', 8, NULL, NULL, 0, 'N', 3, NULL, 'Y')"+ );+ conn.createStatement().execute("INSERT INTO DB_COL_COMMENTS VALUES ('APP_USER', 'ORDERS', 'ORDER_NAME', '订单名称')");+ conn.createStatement().execute(+ "INSERT INTO DB_INDEXES VALUES " ++ "('APP_USER', 'ORDERS', 'IDX_ORDERS_PK', 'Y', 'Y', 'ORDER_ID, REGION_ID'), " ++ "('APP_USER', 'ORDERS', 'IDX_ORDERS_SEQ', 'N', 'N', 'SEQ_NO')"+ );+ conn.createStatement().execute(+ "INSERT INTO DB_IND_COLUMNS VALUES " ++ "('APP_USER', 'IDX_ORDERS_PK', 'APP_USER', 'ORDERS', 'REGION_ID', 2), " ++ "('APP_USER', 'IDX_ORDERS_PK', 'APP_USER', 'ORDERS', 'ORDER_ID', 1), " ++ "('APP_USER', 'IDX_ORDERS_SEQ', 'APP_USER', 'ORDERS', 'SEQ_NO', 1)"+ );++ JsonNode columns = (JsonNode) getColumns.invoke(null, conn, "APP_USER", "orders");+ assertEquals(4, columns.size());+ assertEquals("ORDER_ID", columns.path(0).path("name").asText());+ assertEquals("NUMBER", columns.path(0).path("data_type").asText());+ assertEquals(10, columns.path(0).path("numeric_precision").asInt());+ assertTrue(columns.path(0).path("is_primary_key").asBoolean());+ assertTrue(columns.path(1).path("is_primary_key").asBoolean());+ assertTrue(columns.path(1).path("character_maximum_length").isNull());+ assertEquals("ORDER_NAME", columns.path(2).path("name").asText());+ assertTrue(columns.path(2).path("is_nullable").asBoolean());+ assertEquals(400, columns.path(2).path("character_maximum_length").asInt());+ assertEquals("'none'", columns.path(2).path("column_default").asText());+ assertEquals("订单名称", columns.path(2).path("comment").asText());+ assertFalse(columns.path(3).path("is_primary_key").asBoolean());+ assertEquals("auto_increment", columns.path(3).path("extra").asText());++ JsonNode indexes = (JsonNode) listIndexes.invoke(null, conn, "APP_USER", "ORDERS");+ assertEquals(2, indexes.size());+ assertEquals("IDX_ORDERS_PK", indexes.path(0).path("name").asText());+ assertTrue(indexes.path(0).path("is_primary").asBoolean());+ assertTrue(indexes.path(0).path("is_unique").asBoolean());+ assertEquals(List.of("ORDER_ID", "REGION_ID"), MAPPER.convertValue(indexes.path(0).path("columns"), List.class));+ assertEquals("IDX_ORDERS_SEQ", indexes.path(1).path("name").asText());+ assertFalse(indexes.path(1).path("is_unique").asBoolean());+ }+ }++ @Test+ void zenithObjectSourceReadsViewTextAndRoutineSource() throws Exception {+ Method method = DbxJdbcPlugin.class.getDeclaredMethod(+ "zenithObjectSource",+ Connection.class,+ String.class,+ String.class,+ String.class+ );+ method.setAccessible(true);++ try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:dbx_zenith_source;DB_CLOSE_DELAY=-1", "sa", "")) {+ conn.createStatement().execute("CREATE TABLE DB_VIEWS (OWNER VARCHAR(64), VIEW_NAME VARCHAR(64), TEXT VARCHAR(256))");+ conn.createStatement().execute(+ "CREATE TABLE DB_PROCEDURES (OWNER VARCHAR(64), OBJECT_NAME VARCHAR(64), OBJECT_TYPE VARCHAR(16), SOURCE VARCHAR(256))"+ );+ conn.createStatement().execute("INSERT INTO DB_VIEWS VALUES ('APP_USER', 'V_ORDERS', 'SELECT SEQ_NO FROM ORDERS')");+ conn.createStatement().execute(+ "INSERT INTO DB_PROCEDURES VALUES ('APP_USER', 'F_CALC', 'FUNCTION', 'CREATE OR REPLACE FUNCTION F_CALC RETURN INT')"+ );+ // A same-named procedure must not be returned for a FUNCTION request, and vice versa.+ conn.createStatement().execute(+ "INSERT INTO DB_PROCEDURES VALUES ('APP_USER', 'F_CALC', 'PROCEDURE', 'CREATE OR REPLACE PROCEDURE F_CALC')"+ );++ JsonNode view = (JsonNode) method.invoke(null, conn, "APP_USER", "V_ORDERS", "VIEW");+ assertEquals("CREATE OR REPLACE VIEW \"APP_USER\".\"V_ORDERS\" AS\nSELECT SEQ_NO FROM ORDERS", view.path("source").asText());+ assertFalse(view.path("editable").asBoolean());++ JsonNode function = (JsonNode) method.invoke(null, conn, "APP_USER", "F_CALC", "FUNCTION");+ assertEquals("CREATE OR REPLACE FUNCTION F_CALC RETURN INT", function.path("source").asText());++ JsonNode procedure = (JsonNode) method.invoke(null, conn, "APP_USER", "F_CALC", "PROCEDURE");+ assertEquals("CREATE OR REPLACE PROCEDURE F_CALC", procedure.path("source").asText());+ }+ }++ @Test+ void zenithIndexColumnListSplitsCommaSpaceSeparatedNames() {+ assertEquals(List.of("ORDER_ID", "REGION_ID", "STATUS"), DbxJdbcPlugin.splitZenithIndexColumns("ORDER_ID, REGION_ID, STATUS"));+ assertEquals(List.of(), DbxJdbcPlugin.splitZenithIndexColumns(null));+ }+private static void createPeopleTable() throws Exception {request("executeQuery", """{@@ -3967,6 +4196,37 @@ final class DbxJdbcPluginTest {);}+ /** A connection whose every query fails, mimicking a Zenith login without dictionary or DUAL access. */+ private static Connection zenithFailingConnection(String userName) {+ Statement statement = (Statement) Proxy.newProxyInstance(+ DbxJdbcPluginTest.class.getClassLoader(),+ new Class<?>[] { Statement.class },+ (proxy, method, args) -> {+ if ("executeQuery".equals(method.getName())) {+ throw new SQLException("Query failed: " + args[0]);+ }+ return defaultValue(method.getReturnType());+ }+ );+ DatabaseMetaData metadata = (DatabaseMetaData) Proxy.newProxyInstance(+ DbxJdbcPluginTest.class.getClassLoader(),+ new Class<?>[] { DatabaseMetaData.class },+ (proxy, method, args) -> switch (method.getName()) {+ case "getUserName" -> userName;+ default -> defaultValue(method.getReturnType());+ }+ );+ return (Connection) Proxy.newProxyInstance(+ DbxJdbcPluginTest.class.getClassLoader(),+ new Class<?>[] { Connection.class },+ (proxy, method, args) -> switch (method.getName()) {+ case "createStatement" -> statement;+ case "getMetaData" -> metadata;+ default -> defaultValue(method.getReturnType());+ }+ );+ }+private static Connection metadataConnection(ResultSet columns) {DatabaseMetaData metadata = (DatabaseMetaData) Proxy.newProxyInstance(DbxJdbcPluginTest.class.getClassLoader(),