Skip to content

armgit / dbx

Public Imported from GitHub
0

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。

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.vue
index 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.ts
index 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.ts
index 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.java
index 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.java
index 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(),