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(gbase8s): load column defaults from sysdefaults with literal decoding
弈秋cb05169ac5eb
diff --git a/agents/drivers/gbase8s/src/main/java/com/dbx/agent/gbase8s/Gbase8sAgent.java b/agents/drivers/gbase8s/src/main/java/com/dbx/agent/gbase8s/Gbase8sAgent.javaindex 85967ba150..f86bba9967 100644--- a/agents/drivers/gbase8s/src/main/java/com/dbx/agent/gbase8s/Gbase8sAgent.java+++ b/agents/drivers/gbase8s/src/main/java/com/dbx/agent/gbase8s/Gbase8sAgent.java@@ -522,8 +522,7 @@ public final class Gbase8sAgent extends ConfiguredJdbcAgent {Connection conn = requireConnection();String owner = trim(schema);Set<Integer> primaryKeyColumns = getPrimaryKeyColumnNumbers(conn, owner, table);- boolean mysqlCompatMode = isMysqlCompatMode(databaseListParams);- Map<String, String> columnDefaults = loadColumnDefaults(conn, owner, table, mysqlCompatMode);+ Map<String, String> columnDefaults = loadColumnDefaults(conn, owner, table);try {return loadColumns(conn, owner, table, true, primaryKeyColumns, columnDefaults);} catch (Exception ignored) {@@ -604,40 +603,203 @@ public final class Gbase8sAgent extends ConfiguredJdbcAgent {}private static Map<String, String> loadColumnDefaults(+ Connection conn,+ String owner,+ String table+ ) {+ // sysdefaults is the canonical catalog for column defaults (referenced+ // through syscolumns.coldefault) and covers literal, USER/CURRENT/TODAY+ // and NULL defaults; sysdefaultsexpr only exposes compiled expression+ // defaults, which is why tables whose defaults are plain literals came+ // back empty before (issue #13220). Query both and keep the first value+ // per column; either source failing leaves the other usable.+ //+ // sysdefaults layout (GBase 8s SQL Reference / IBM SYSDEFAULTS): the+ // key is tabid+colno+class, there is no seqno column, `class` marks the+ // column category (T = table column), and `type` holds the DEFAULT+ // clause marker (C=Current, L=Literal, N=NULL, S=Dbservername, T=Today,+ // U=User) with the literal itself in `default`.+ //+ // Literal defaults of non-character columns are stored ENCODED: the+ // `default` column holds a 6-bit binary prefix, a blank, then the ASCII+ // text (IBM Informix 12.10 SYSDEFAULTS). Decode them server-side with+ // the builtin gbasedbt.get_default_value(c.coltype, c.extended_id,+ // c.collength, d.default::lvarchar(256)) — the same call DBeaver's+ // GBase 8s meta model and GBase's DDL-reconstruction recipe use. The+ // builtin returns character literals unquoted, so quotes are re-added+ // per column type below. Servers whose build lacks the builtin (older+ // GBase 8s / Informix, where the routine is informix.get_default_value+ // or absent) fall back to the plain undecoded query instead of losing+ // every default.+ //+ // The `default` catalog column is always backtick-quoted: the GBase JDBC+ // driver's statement parser rejects a bare `default` column reference+ // with a syntax error (even though dbaccess parses it), in every+ // SQLMODE, while the backtick form is accepted in both the server's+ // standard mode and SQLMODE=mysql (verified against GBase 8s 8.8 with+ // driver 3.6.5.21).+ Map<String, String> defaults = new LinkedHashMap<>();+ if (loadColumnDefaultsFromSource(+ defaults,+ conn,+ owner,+ table,+ """+ SELECT c.colname, c.coltype,+ CASE d.type+ WHEN 'L' THEN gbasedbt.get_default_value(c.coltype, c.extended_id, c.collength, d.`default`::lvarchar(256))+ ELSE d.`default`+ END AS column_default,+ d.type AS default_class+ FROM systables t+ JOIN syscolumns c ON t.tabid = c.tabid+ JOIN sysdefaults d ON d.tabid = c.tabid AND d.colno = c.colno+ WHERE t.tabname = ? AND d.class = 'T'+ """.stripIndent().trim(),+ true,+ true+ ) == DefaultsQueryOutcome.DECODE_ROUTINE_MISSING) {+ loadColumnDefaultsFromSource(+ defaults,+ conn,+ owner,+ table,+ """+ SELECT c.colname, c.coltype, d.`default` AS column_default, d.type AS default_class+ FROM systables t+ JOIN syscolumns c ON t.tabid = c.tabid+ JOIN sysdefaults d ON d.tabid = c.tabid AND d.colno = c.colno+ WHERE t.tabname = ? AND d.class = 'T'+ """.stripIndent().trim(),+ true,+ false+ );+ }+ loadColumnDefaultsFromSource(+ defaults,+ conn,+ owner,+ table,+ """+ SELECT c.colname, e.`default` AS column_default+ FROM systables t+ JOIN syscolumns c ON t.tabid = c.tabid+ JOIN sysdefaultsexpr e ON c.tabid = e.tabid AND c.colno = e.colno+ WHERE t.tabname = ? AND e.type = 'T'+ """.stripIndent().trim(),+ false,+ false+ );+ return defaults;+ }++ private enum DefaultsQueryOutcome {+ COMPLETED,+ DECODE_ROUTINE_MISSING,+ FAILED+ }++ private static DefaultsQueryOutcome loadColumnDefaultsFromSource(+ Map<String, String> defaults,Connection conn,String owner,String table,- boolean mysqlCompatMode+ String sqlText,+ boolean hasDefaultClass,+ boolean decodeLiterals) {List<Object> args = new ArrayList<>();args.add(table);- StringBuilder sql = new StringBuilder("""- SELECT c.colname, %s AS column_default- FROM systables t- JOIN syscolumns c ON t.tabid = c.tabid- JOIN sysdefaultsexpr e ON c.tabid = e.tabid AND c.colno = e.colno- WHERE t.tabname = ? AND e.type = 'T'- """.formatted(mysqlCompatMode ? "e.`default`" : "e.default").stripIndent().trim());+ StringBuilder sql = new StringBuilder(sqlText);if (!owner.isEmpty()) {sql.append(" AND t.owner = ?");args.add(owner);}- Map<String, String> defaults = new LinkedHashMap<>();try (PreparedStatement stmt = conn.prepareStatement(sql.toString())) {bind(stmt, args);try (ResultSet rs = stmt.executeQuery()) {while (rs.next()) {- String value = sanitizeColumnDefault(rs.getString("column_default"));+ String value = rs.getString("column_default");+ String defaultClass = hasDefaultClass ? rs.getString("default_class") : null;+ // sysdefaults (decoded or raw) returns character literals+ // unquoted, so both sysdefaults queries re-add the quotes by+ // column type; sysdefaultsexpr rows are expression text and+ // are passed through as-is.+ if (hasDefaultClass+ && "L".equals(defaultClass)+ && value != null+ && isCharFamilyColType(rs.getInt("coltype"))) {+ value = quoteCharacterDefault(value);+ }+ value = sanitizeColumnDefault(value);+ if (value == null && hasDefaultClass) {+ // sysdefaults stores keyword defaults with a NULL value+ // and the class marker instead; surface the DEFAULT+ // clause keyword the class stands for.+ value = defaultClassKeyword(defaultClass);+ }if (value != null) {- defaults.put(trim(rs.getString("colname")), value);+ defaults.putIfAbsent(trim(rs.getString("colname")), value);}}}- } catch (SQLException ignored) {- return Collections.emptyMap();+ } catch (SQLException e) {+ // Either catalog failing (older servers may lack the view or the+ // decoding builtin) leaves whatever the other source contributed in+ // place, but never silently: the failure is visible on stderr.+ if (decodeLiterals && missingDecodeRoutine(e)) {+ System.err.println(+ "[gbase8s] gbasedbt.get_default_value unavailable, retrying sysdefaults undecoded: " + e.getMessage());+ return DefaultsQueryOutcome.DECODE_ROUTINE_MISSING;+ }+ System.err.println("[gbase8s] column defaults query failed, skipping this defaults source: " + e.getMessage());+ return DefaultsQueryOutcome.FAILED;}- return defaults;+ return DefaultsQueryOutcome.COMPLETED;+ }++ /** Whether a sysdefaults failure is the server lacking the literal-decoding builtin it names. */+ private static boolean missingDecodeRoutine(SQLException e) {+ String message = e.getMessage();+ return message != null && message.toLowerCase(Locale.ROOT).contains("get_default_value");+ }++ /**+ * get_default_value returns character literals unquoted, but a DEFAULT clause needs them+ * quoted (GBase's DDL-reconstruction recipe re-adds the quotes by column type), so wrap+ * the decoded literal and double embedded quotes. The value is not trimmed: surrounding+ * blanks can be part of the literal.+ */+ static String quoteCharacterDefault(String decoded) {+ String literal = decoded == null ? "" : decoded;+ int nullIndex = literal.indexOf('\0');+ if (nullIndex >= 0) {+ literal = literal.substring(0, nullIndex);+ }+ return "'" + literal.replace("'", "''") + "'";+ }++ /** Whether the syscolumns coltype is a character type whose decoded literal must be re-quoted. */+ static boolean isCharFamilyColType(int coltype) {+ int baseType = baseColType(coltype);+ return baseType == 0 /* CHAR */ || baseType == 13 /* VARCHAR */ || baseType == 15 /* NCHAR */+ || baseType == 16 /* NVARCHAR */ || baseType == 40 /* LVARCHAR */;+ }++ /** The Informix DEFAULT clause keyword a sysdefaults.type marker stands for. */+ static String defaultClassKeyword(String defaultClass) {+ if (defaultClass == null) {+ return null;+ }+ return switch (defaultClass) {+ case "U" -> "USER";+ case "C" -> "CURRENT";+ case "T" -> "TODAY";+ case "S" -> "DBSERVERNAME";+ case "N" -> "NULL";+ default -> null;+ };}public static String sanitizeColumnDefault(String value) {@@ -652,17 +814,6 @@ public final class Gbase8sAgent extends ConfiguredJdbcAgent {return value.isEmpty() ? null : value;}- private static boolean isMysqlCompatMode(ConnectParams params) {- if (params == null) {- return false;- }- if (params.isMysql_compat_mode()) {- return true;- }- String sqlMode = connectionParameterValue(buildUrl(params), "SQLMODE");- return sqlMode.equalsIgnoreCase("mysql");- }-@Overridepublic List<IndexInfo> listIndexes(String schema, String table) {try {diff --git a/agents/drivers/gbase8s/src/test/java/com/dbx/agent/gbase8s/Gbase8sAgentTest.java b/agents/drivers/gbase8s/src/test/java/com/dbx/agent/gbase8s/Gbase8sAgentTest.javaindex 7a20684f44..6823647633 100644--- a/agents/drivers/gbase8s/src/test/java/com/dbx/agent/gbase8s/Gbase8sAgentTest.java+++ b/agents/drivers/gbase8s/src/test/java/com/dbx/agent/gbase8s/Gbase8sAgentTest.java@@ -403,6 +403,7 @@ class Gbase8sAgentTest {{1, 0, null, null, null, null, null, null, null, null, null, null, null, null, null, null}}),+ resultSet(new String[]{"colname", "column_default", "default_class"}, new Object[][]{}),resultSet(new String[]{"colname", "column_default"}, new Object[][]{}),resultSet(new String[]{"colname", "coltype", "colno", "collength", "comments"},@@ -420,13 +421,19 @@ class Gbase8sAgentTest {List<ColumnInfo> columns = agent.getColumns("root", "products");- Assertions.assertEquals(3, sql.size());+ Assertions.assertEquals(4, sql.size());Assertions.assertTrue(sql.get(0).contains("FROM sysconstraints"), sql.get(0));Assertions.assertTrue(sql.get(0).contains("t.owner = ?"), sql.get(0));- Assertions.assertTrue(sql.get(1).contains("JOIN sysdefaultsexpr"), sql.get(1));- Assertions.assertTrue(sql.get(1).contains("e.default AS column_default"), sql.get(1));- Assertions.assertTrue(sql.get(2).contains("FROM syscolumns"), sql.get(2));- Assertions.assertTrue(sql.get(2).contains("t.owner = ?"), sql.get(2));+ Assertions.assertTrue(sql.get(1).contains("JOIN sysdefaults"), sql.get(1));+ Assertions.assertTrue(sql.get(1).contains("gbasedbt.get_default_value("), sql.get(1));+ Assertions.assertTrue(sql.get(1).contains("WHEN 'L' THEN gbasedbt.get_default_value(c.coltype, c.extended_id, c.collength, d.`default`::lvarchar(256))"), sql.get(1));+ Assertions.assertTrue(sql.get(1).contains("ELSE d.`default`"), sql.get(1));+ Assertions.assertTrue(sql.get(1).contains("d.class = 'T'"), sql.get(1));+ Assertions.assertFalse(sql.get(1).contains("seqno"), sql.get(1));+ Assertions.assertTrue(sql.get(2).contains("JOIN sysdefaultsexpr"), sql.get(2));+ Assertions.assertTrue(sql.get(2).contains("e.`default` AS column_default"), sql.get(2));+ Assertions.assertTrue(sql.get(3).contains("FROM syscolumns"), sql.get(3));+ Assertions.assertTrue(sql.get(3).contains("t.owner = ?"), sql.get(3));Assertions.assertEquals(3, columns.size());Assertions.assertEquals("product_id", columns.get(0).getName());Assertions.assertEquals("INTEGER", columns.get(0).getData_type());@@ -439,7 +446,7 @@ class Gbase8sAgentTest {Assertions.assertEquals(2, columns.get(2).getNumeric_scale());Assertions.assertEquals("Product identifier", columns.get(0).getComment());Assertions.assertEquals("Unit price", columns.get(2).getComment());- Assertions.assertTrue(sql.get(2).contains("LEFT JOIN syscolcomms"), sql.get(2));+ Assertions.assertTrue(sql.get(3).contains("LEFT JOIN syscolcomms"), sql.get(3));}@Test@@ -448,6 +455,7 @@ class Gbase8sAgentTest {TestSupport.setPrivateConnection(agent, preparedConnection(new ArrayList<>(),resultSet(new String[]{"part1"}, new Object[][]{}),+ resultSet(new String[]{"colname", "column_default", "default_class"}, new Object[][]{}),resultSet(new String[]{"colname", "column_default"}, new Object[][]{}),resultSet(new String[]{"colname", "coltype", "colno", "collength", "comments"},@@ -503,6 +511,7 @@ class Gbase8sAgentTest {TestSupport.setPrivateConnection(agent, preparedConnection(sql,resultSet(new String[]{"part1"}, new Object[][]{}),+ resultSet(new String[]{"colname", "column_default", "default_class"}, new Object[][]{}),resultSet(new String[]{"colname", "column_default"}, new Object[][]{}),resultSet(new String[]{"colname", "coltype", "colno", "collength", "comments", "extended_name"},@@ -518,7 +527,7 @@ class Gbase8sAgentTest {List<ColumnInfo> columns = agent.getColumns("root", "media");- Assertions.assertTrue(sql.get(2).contains("LEFT JOIN sysxtdtypes x ON x.extended_id = c.extended_id"), sql.get(2));+ Assertions.assertTrue(sql.get(3).contains("LEFT JOIN sysxtdtypes x ON x.extended_id = c.extended_id"), sql.get(3));Assertions.assertEquals(5, columns.size());// BLOB and CLOB must NOT be misidentified as BOOLEAN@@ -558,6 +567,7 @@ class Gbase8sAgentTest {TestSupport.setPrivateConnection(agent, fallbackOnSysxtdtypesFailureConnection(sql,resultSet(new String[]{"part1"}, new Object[][]{}),+ resultSet(new String[]{"colname", "column_default", "default_class"}, new Object[][]{}),resultSet(new String[]{"colname", "column_default"}, new Object[][]{}),// When query with sysxtdtypes fails, fallback query without sysxtdtypes succeedsresultSet(@@ -586,6 +596,7 @@ class Gbase8sAgentTest {new String[]{"part1", "part2", "part3", "part4", "part5", "part6", "part7", "part8", "part9", "part10", "part11", "part12", "part13", "part14", "part15", "part16"},new Object[][]{{1, 0, null, null, null, null, null, null, null, null, null, null, null, null, null, null}}),+ resultSet(new String[]{"colname", "column_default", "default_class"}, new Object[][]{}),resultSet(new String[]{"colname", "column_default"},new Object[][]{{"op_id", "'0'"}, {"created_at", "current_timestamp"}}@@ -613,16 +624,121 @@ class Gbase8sAgentTest {List<ColumnInfo> columns = agent.getColumns("root", "system_user");- Assertions.assertEquals(3, sql.size());- Assertions.assertTrue(sql.get(1).contains("JOIN sysdefaultsexpr"), sql.get(1));- Assertions.assertTrue(sql.get(1).contains("e.type = 'T'"), sql.get(1));- Assertions.assertTrue(sql.get(1).contains("e.`default` AS column_default"), sql.get(1));- Assertions.assertTrue(sql.get(1).contains("t.owner = ?"), sql.get(1));+ Assertions.assertEquals(4, sql.size());+ Assertions.assertTrue(sql.get(1).contains("JOIN sysdefaults"), sql.get(1));+ Assertions.assertTrue(sql.get(1).contains("gbasedbt.get_default_value("), sql.get(1));+ Assertions.assertTrue(sql.get(1).contains("d.`default`::lvarchar(256)"), sql.get(1));+ Assertions.assertTrue(sql.get(2).contains("JOIN sysdefaultsexpr"), sql.get(2));+ Assertions.assertTrue(sql.get(2).contains("e.type = 'T'"), sql.get(2));+ Assertions.assertTrue(sql.get(2).contains("e.`default` AS column_default"), sql.get(2));+ Assertions.assertTrue(sql.get(2).contains("t.owner = ?"), sql.get(2));Assertions.assertNull(columns.get(0).getColumn_default());Assertions.assertEquals("'0'", columns.get(1).getColumn_default());Assertions.assertEquals("current_timestamp", columns.get(2).getColumn_default());}+ @Test+ void getColumnsLoadsDefaultsFromSysdefaultsTypeMarkers() throws Exception {+ List<String> sql = new ArrayList<>();+ Gbase8sAgent agent = new Gbase8sAgent();+ Connection connection = preparedConnection(+ sql,+ resultSet(+ new String[]{"part1", "part2", "part3", "part4", "part5", "part6", "part7", "part8", "part9", "part10", "part11", "part12", "part13", "part14", "part15", "part16"},+ new Object[][]{}+ ),+ // Rows shaped like the decoding query: type='L' rows carry the+ // gbasedbt.get_default_value() result — decoded ("0", unencoded)+ // for the INTEGER column and unquoted for the VARCHAR column.+ resultSet(+ new String[]{"colname", "coltype", "column_default", "default_class"},+ new Object[][]{+ {"status", 13, "active", "L"},+ {"quantity", 2, "0", "L"},+ {"created_by", 13, null, "U"},+ {"created_at", 10, null, "C"}+ }+ ),+ resultSet(new String[]{"colname", "column_default"}, new Object[][]{}),+ resultSet(+ new String[]{"colname", "coltype", "colno", "collength", "comments"},+ new Object[][]{+ {"id", 258, 1, 4, null},+ {"status", 13, 2, 20, null},+ {"quantity", 2, 3, 4, null},+ {"created_by", 13, 4, 32, null},+ {"created_at", 10, 5, 8, null}+ }+ )+ );+ TestSupport.setPrivateConnection(agent, connection);+ agent.afterConnect(new ConnectParams("localhost", 9088, "appdb", "", "", "GBASEDBTSERVER=gbase8s;", "", false), connection);++ List<ColumnInfo> columns = agent.getColumns("root", "orders");++ Assertions.assertEquals(4, sql.size());+ Assertions.assertTrue(sql.get(1).contains("JOIN sysdefaults"), sql.get(1));+ Assertions.assertTrue(sql.get(1).contains("gbasedbt.get_default_value("), sql.get(1));+ Assertions.assertTrue(sql.get(1).contains("WHEN 'L' THEN gbasedbt.get_default_value(c.coltype, c.extended_id, c.collength, d.`default`::lvarchar(256))"), sql.get(1));+ Assertions.assertTrue(sql.get(1).contains("d.class = 'T'"), sql.get(1));+ Assertions.assertFalse(sql.get(1).contains("seqno"), sql.get(1));+ Assertions.assertNull(columns.get(0).getColumn_default());+ // Character literals come back unquoted from the builtin, so quotes are re-added.+ Assertions.assertEquals("'active'", columns.get(1).getColumn_default());+ // Non-character literals are decoded without any 6-bit prefix or quotes.+ Assertions.assertEquals("0", columns.get(2).getColumn_default());+ Assertions.assertEquals("USER", columns.get(3).getColumn_default());+ Assertions.assertEquals("CURRENT", columns.get(4).getColumn_default());+ }++ @Test+ void sysdefaultsValuesWinOverExpressionCatalogEntriesForTheSameColumn() throws Exception {+ List<String> sql = new ArrayList<>();+ Gbase8sAgent agent = new Gbase8sAgent();+ Connection connection = preparedConnection(+ sql,+ resultSet(+ new String[]{"part1", "part2", "part3", "part4", "part5", "part6", "part7", "part8", "part9", "part10", "part11", "part12", "part13", "part14", "part15", "part16"},+ new Object[][]{}+ ),+ resultSet(+ new String[]{"colname", "coltype", "column_default", "default_class"},+ new Object[][]{{"level", 2, "1", "L"}}+ ),+ resultSet(+ new String[]{"colname", "column_default"},+ new Object[][]{{"level", "level_seq.nextval"}, {"extra", "expr"}}+ ),+ resultSet(+ new String[]{"colname", "coltype", "colno", "collength", "comments"},+ new Object[][]{+ {"id", 258, 1, 4, null},+ {"level", 2, 2, 4, null}+ }+ )+ );+ TestSupport.setPrivateConnection(agent, connection);+ agent.afterConnect(new ConnectParams("localhost", 9088, "appdb", "", "", "GBASEDBTSERVER=gbase8s;", "", false), connection);++ List<ColumnInfo> columns = agent.getColumns("root", "levels");++ // The canonical sysdefaults value is kept; the expression row for the+ // same column is ignored, while a column only the expression catalog+ // knows still contributes.+ Assertions.assertEquals("1", columns.get(1).getColumn_default());+ }++ @Test+ void defaultClassKeywordMapsInformixDefaultClauseKeywords() {+ Assertions.assertEquals("USER", Gbase8sAgent.defaultClassKeyword("U"));+ Assertions.assertEquals("CURRENT", Gbase8sAgent.defaultClassKeyword("C"));+ Assertions.assertEquals("TODAY", Gbase8sAgent.defaultClassKeyword("T"));+ Assertions.assertEquals("DBSERVERNAME", Gbase8sAgent.defaultClassKeyword("S"));+ Assertions.assertEquals("NULL", Gbase8sAgent.defaultClassKeyword("N"));+ Assertions.assertNull(Gbase8sAgent.defaultClassKeyword("L"));+ Assertions.assertNull(Gbase8sAgent.defaultClassKeyword(null));+ }+@Testvoid sanitizeColumnDefaultStripsTrailingNulBytesAndEmptyExpressions() {Assertions.assertEquals("'2'", Gbase8sAgent.sanitizeColumnDefault("'2'\0\0\0"));@@ -645,21 +761,26 @@ class Gbase8sAgentTest {new String[]{"part1", "part2", "part3", "part4", "part5", "part6", "part7", "part8", "part9", "part10", "part11", "part12", "part13", "part14", "part15", "part16"},new Object[][]{{1, 0, null, null, null, null, null, null, null, null, null, null, null, null, null, null}}),+ // Rows shaped like the decoding query: decoded literals per column+ // type, possibly with stray NUL padding from the catalog column.resultSet(- new String[]{"colname", "column_default"},+ new String[]{"colname", "coltype", "column_default", "default_class"},new Object[][]{- {"show_status", "'2'\0\0\0\0\0"},- {"name", "''\0\0\0\0\0"},- {"empty_default", "\0\0\0"}+ {"show_status", 257, "2", "L"},+ {"name", 13, "", "L"},+ {"banner", 256, "hi\0\0", "L"},+ {"empty_default", 258, null, "L"}}),+ resultSet(new String[]{"colname", "column_default"}, new Object[][]{}),resultSet(new String[]{"colname", "coltype", "colno", "collength", "comments"},new Object[][]{{"id", 258, 1, 4, null},{"show_status", 257, 2, 2, null},- {"name", 269, 3, 765, null},- {"empty_default", 258, 4, 4, null}+ {"name", 13, 3, 765, null},+ {"banner", 256, 4, 8, null},+ {"empty_default", 258, 5, 4, null}}));@@ -669,48 +790,61 @@ class Gbase8sAgentTest {), connection);List<ColumnInfo> columns = agent.getColumns("root", "test_table");- Assertions.assertEquals(4, columns.size());+ Assertions.assertEquals(5, columns.size());Assertions.assertNull(columns.get(0).getColumn_default());- Assertions.assertEquals("'2'", columns.get(1).getColumn_default());+ // Non-character literals decode to plain unquoted SQL.+ Assertions.assertEquals("2", columns.get(1).getColumn_default());+ // An empty character literal keeps its quotes.Assertions.assertEquals("''", columns.get(2).getColumn_default());- Assertions.assertNull(columns.get(3).getColumn_default());+ // NUL padding is cut before the character literal is re-quoted.+ Assertions.assertEquals("'hi'", columns.get(3).getColumn_default());+ Assertions.assertNull(columns.get(4).getColumn_default());String ddl = DdlBuilder.buildTableDdl("root", "test_table", columns, List.of(), List.of());Assertions.assertFalse(ddl.contains("\0"), "DDL must not contain NUL bytes");- Assertions.assertTrue(ddl.contains("\"show_status\" SMALLINT NOT NULL DEFAULT '2'"));- Assertions.assertTrue(ddl.contains("\"name\" VARCHAR(765) NOT NULL DEFAULT ''"));+ Assertions.assertTrue(ddl.contains("\"show_status\" SMALLINT NOT NULL DEFAULT 2"));+ Assertions.assertTrue(ddl.contains("\"name\" VARCHAR(765) DEFAULT ''"));+ Assertions.assertTrue(ddl.contains("\"banner\" CHAR(8) NOT NULL DEFAULT 'hi'"));Assertions.assertTrue(ddl.contains("\"empty_default\" INTEGER NOT NULL"));Assertions.assertFalse(ddl.contains("\"empty_default\" INTEGER NOT NULL DEFAULT"));}@Test- void getColumnsUsesMysqlModeFromCustomConnectionStringBeforeUrlParams() {- String sql = defaultExpressionSql(- "SQLMODE=ansi",- "jdbc:gbasedbt-sqli://localhost:9088/appdb:GBASEDBTSERVER=gbase8s;SQLMODE=mysql"- );-- Assertions.assertTrue(sql.contains("e.`default` AS column_default"), sql);- }-- @Test- void getColumnsUsesAnsiModeFromCustomConnectionStringBeforeUrlParams() {- String sql = defaultExpressionSql(- "SQLMODE=mysql",- "jdbc:gbasedbt-sqli://localhost:9088/appdb:GBASEDBTSERVER=gbase8s;SQLMODE=ansi"- );-- Assertions.assertTrue(sql.contains("e.default AS column_default"), sql);- }+ void defaultsQueriesBacktickTheReservedDefaultColumnInEverySqlMode() {+ // The GBase JDBC driver rejects a bare `default` column reference with a+ // syntax error regardless of SQLMODE, so both defaults catalogs are+ // always queried through the backtick-quoted form (verified against a+ // real GBase 8s 8.8 server with driver 3.6.5.21 in standard mode and+ // SQLMODE=mysql).+ String[][] configs = {+ {"SQLMODE=ansi", "jdbc:gbasedbt-sqli://localhost:9088/appdb:GBASEDBTSERVER=gbase8s;SQLMODE=mysql"},+ {"SQLMODE=mysql", "jdbc:gbasedbt-sqli://localhost:9088/appdb:GBASEDBTSERVER=gbase8s;SQLMODE=ansi"},+ {"SQLMODE=mysql", "jdbc:gbasedbt-sqli://localhost:9088/appdb:GBASEDBTSERVER=gbase8s"}+ };+ for (String[] config : configs) {+ List<String> sql = new ArrayList<>();+ Gbase8sAgent agent = new Gbase8sAgent();+ Connection connection = preparedConnection(+ sql,+ resultSet(+ new String[]{"part1", "part2", "part3", "part4", "part5", "part6", "part7", "part8", "part9", "part10", "part11", "part12", "part13", "part14", "part15", "part16"},+ new Object[][]{}+ ),+ resultSet(new String[]{"colname", "coltype", "column_default", "default_class"}, new Object[][]{}),+ resultSet(new String[]{"colname", "column_default"}, new Object[][]{}),+ resultSet(new String[]{"colname", "coltype", "colno", "collength", "comments"}, new Object[][]{})+ );+ TestSupport.setPrivateConnection(agent, connection);+ agent.afterConnect(new ConnectParams(+ "localhost", 9088, "appdb", "", "", config[0], config[1], false+ ), connection);- @Test- void getColumnsIgnoresUrlParamsWhenCustomConnectionStringOmitsSqlMode() {- String sql = defaultExpressionSql(- "SQLMODE=mysql",- "jdbc:gbasedbt-sqli://localhost:9088/appdb:GBASEDBTSERVER=gbase8s"- );+ agent.getColumns("root", "system_user");- Assertions.assertTrue(sql.contains("e.default AS column_default"), sql);+ Assertions.assertTrue(sql.get(1).contains("d.`default`::lvarchar(256)"), sql.get(1));+ Assertions.assertFalse(sql.get(1).contains("ELSE d.default "), sql.get(1));+ Assertions.assertTrue(sql.get(2).contains("e.`default` AS column_default"), sql.get(2));+ }}@Test@@ -731,13 +865,94 @@ class Gbase8sAgentTest {List<ColumnInfo> columns = agent.getColumns("root", "system_user");- Assertions.assertEquals(3, sql.size());- Assertions.assertTrue(sql.get(1).contains("JOIN sysdefaultsexpr"), sql.get(1));+ // Both default catalogs fail; the columns query still runs and columns+ // come back without defaults.+ Assertions.assertEquals(4, sql.size());+ Assertions.assertTrue(sql.get(1).contains("JOIN sysdefaults"), sql.get(1));+ Assertions.assertTrue(sql.get(2).contains("JOIN sysdefaultsexpr"), sql.get(2));Assertions.assertEquals(2, columns.size());Assertions.assertNull(columns.get(0).getColumn_default());Assertions.assertNull(columns.get(1).getColumn_default());}+ @Test+ void getColumnsFallsBackToRawSysdefaultsWhenDecodeRoutineIsMissing() {+ List<String> sql = new ArrayList<>();+ Gbase8sAgent agent = new Gbase8sAgent();+ TestSupport.setPrivateConnection(agent, decodeRoutineMissingConnection(+ sql,+ resultSet(+ new String[]{"part1", "part2", "part3", "part4", "part5", "part6", "part7", "part8", "part9", "part10", "part11", "part12", "part13", "part14", "part15", "part16"},+ new Object[][]{}+ ),+ // Rows shaped like the plain undecoded query: raw `default` text,+ // where character literals are unquoted and non-character ones+ // carry the 6-bit prefix documented by IBM SYSDEFAULTS.+ resultSet(+ new String[]{"colname", "coltype", "column_default", "default_class"},+ new Object[][]{+ {"status", 13, "active", "L"},+ {"quantity", 2, "xn9g 0", "L"},+ {"created_by", 13, null, "U"}+ }+ ),+ resultSet(new String[]{"colname", "column_default"}, new Object[][]{}),+ resultSet(+ new String[]{"colname", "coltype", "colno", "collength", "comments"},+ new Object[][]{+ {"status", 13, 1, 20, null},+ {"quantity", 2, 2, 4, null},+ {"created_by", 13, 3, 32, null}+ }+ )+ ));++ List<ColumnInfo> columns = agent.getColumns("root", "orders");++ // The decoding query fails on the missing builtin, the plain sysdefaults+ // query runs in its place, and defaults are still populated (character+ // literals still re-quoted by column type).+ Assertions.assertEquals(5, sql.size());+ Assertions.assertTrue(sql.get(1).contains("gbasedbt.get_default_value("), sql.get(1));+ Assertions.assertFalse(sql.get(2).contains("get_default_value"), sql.get(2));+ Assertions.assertTrue(sql.get(2).contains("d.`default` AS column_default"), sql.get(2));+ Assertions.assertTrue(sql.get(3).contains("JOIN sysdefaultsexpr"), sql.get(3));+ Assertions.assertEquals("'active'", columns.get(0).getColumn_default());+ Assertions.assertEquals("xn9g 0", columns.get(1).getColumn_default());+ Assertions.assertEquals("USER", columns.get(2).getColumn_default());+ }++ @Test+ void charFamilyColTypesCoverInformixCharacterTypesOnly() {+ // CHAR, VARCHAR, NCHAR, NVARCHAR, LVARCHAR — with and without the+ // nullable-flag bits above the base type.+ Assertions.assertTrue(Gbase8sAgent.isCharFamilyColType(0));+ Assertions.assertTrue(Gbase8sAgent.isCharFamilyColType(13));+ Assertions.assertTrue(Gbase8sAgent.isCharFamilyColType(15));+ Assertions.assertTrue(Gbase8sAgent.isCharFamilyColType(16));+ Assertions.assertTrue(Gbase8sAgent.isCharFamilyColType(40));+ Assertions.assertTrue(Gbase8sAgent.isCharFamilyColType(13 + 256));+ // Numeric, date/time and extended (BOOLEAN/BLOB) literals stay unquoted.+ Assertions.assertFalse(Gbase8sAgent.isCharFamilyColType(1));+ Assertions.assertFalse(Gbase8sAgent.isCharFamilyColType(2));+ Assertions.assertFalse(Gbase8sAgent.isCharFamilyColType(5));+ Assertions.assertFalse(Gbase8sAgent.isCharFamilyColType(7));+ Assertions.assertFalse(Gbase8sAgent.isCharFamilyColType(10));+ Assertions.assertFalse(Gbase8sAgent.isCharFamilyColType(41));+ }++ @Test+ void quoteCharacterDefaultWrapsAndDoublesQuotes() {+ Assertions.assertEquals("'active'", Gbase8sAgent.quoteCharacterDefault("active"));+ // An empty character literal still gets its quotes.+ Assertions.assertEquals("''", Gbase8sAgent.quoteCharacterDefault(""));+ Assertions.assertEquals("''", Gbase8sAgent.quoteCharacterDefault(null));+ // Embedded quotes are doubled, NUL padding is cut, inner blanks kept.+ Assertions.assertEquals("'it''s'", Gbase8sAgent.quoteCharacterDefault("it's"));+ Assertions.assertEquals("'hi'", Gbase8sAgent.quoteCharacterDefault("hi\0\0"));+ Assertions.assertEquals("' padded '", Gbase8sAgent.quoteCharacterDefault(" padded "));+ }+@Testvoid listIndexesLoadsGbase8sSystemCatalogIndexes() {List<String> sql = new ArrayList<>();@@ -925,28 +1140,6 @@ class Gbase8sAgentTest {});}- private static String defaultExpressionSql(String urlParams, String connectionString) {- List<String> sql = new ArrayList<>();- Gbase8sAgent agent = new Gbase8sAgent();- Connection connection = preparedConnection(- sql,- resultSet(- new String[]{"part1", "part2", "part3", "part4", "part5", "part6", "part7", "part8", "part9", "part10", "part11", "part12", "part13", "part14", "part15", "part16"},- new Object[][]{}- ),- resultSet(new String[]{"colname", "column_default"}, new Object[][]{}),- resultSet(new String[]{"colname", "coltype", "colno", "collength", "comments"}, new Object[][]{})- );- TestSupport.setPrivateConnection(agent, connection);- agent.afterConnect(new ConnectParams(- "localhost", 9088, "appdb", "", "", urlParams, connectionString, false- ), connection);-- agent.getColumns("root", "system_user");-- return sql.get(1);- }-private static Connection defaultQueryFailureConnection(List<String> sql, ResultSet... resultSets) {int[] resultIndex = {0};return proxy(Connection.class, (method, args) -> {@@ -958,7 +1151,7 @@ class Gbase8sAgentTest {sql.add(query);return proxy(PreparedStatement.class, (statementMethod, statementArgs) -> {if ("executeQuery".equals(statementMethod.getName())) {- if (query.contains("sysdefaultsexpr")) {+ if (query.contains("sysdefault")) {throw new SQLException("Backtick identifiers are not supported");}return resultSets[resultIndex[0]++];@@ -973,6 +1166,32 @@ class Gbase8sAgentTest {});}+ private static Connection decodeRoutineMissingConnection(List<String> sql, ResultSet... resultSets) {+ int[] resultIndex = {0};+ return proxy(Connection.class, (method, args) -> {+ if ("getCatalog".equals(method.getName())) {+ return "appdb";+ }+ if ("prepareStatement".equals(method.getName())) {+ String query = String.valueOf(args[0]);+ sql.add(query);+ return proxy(PreparedStatement.class, (statementMethod, statementArgs) -> {+ if ("executeQuery".equals(statementMethod.getName())) {+ if (query.contains("get_default_value")) {+ throw new SQLException("Routine (get_default_value) cannot be resolved.");+ }+ return resultSets[resultIndex[0]++];+ }+ return defaultValue(statementMethod.getReturnType());+ });+ }+ if ("isClosed".equals(method.getName())) {+ return false;+ }+ return defaultValue(method.getReturnType());+ });+ }+private static Connection fallbackOnSysxtdtypesFailureConnection(List<String> sql, ResultSet... resultSets) {int[] resultIndex = {0};return proxy(Connection.class, (method, args) -> {diff --git a/agents/drivers/gbase8s/src/test/java/com/dbx/agent/gbase8s/Gbase8sColumnDefaultsLiveTest.java b/agents/drivers/gbase8s/src/test/java/com/dbx/agent/gbase8s/Gbase8sColumnDefaultsLiveTest.javanew file mode 100644index 0000000000..ac3b6cf48d--- /dev/null+++ b/agents/drivers/gbase8s/src/test/java/com/dbx/agent/gbase8s/Gbase8sColumnDefaultsLiveTest.java@@ -0,0 +1,73 @@+package com.dbx.agent.gbase8s;++import com.dbx.agent.ColumnInfo;+import com.dbx.agent.ConnectParams;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;+import java.util.UUID;+import org.junit.jupiter.api.Assertions;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable;++/**+ * Real-instance check for column defaults loaded from sysdefaults: literal defaults of+ * non-character columns are stored 6-bit encoded and must come back decoded through+ * gbasedbt.get_default_value, character literals keep their quotes, and NULL /+ * expression defaults surface through their own catalogs.+ *+ * NOTE: keyword defaults (USER / CURRENT / TODAY / DBSERVERNAME) are not created here+ * because the pinned GBase JDBC driver cannot express them in DDL through the sqli+ * gateway: DEFAULT USER / DEFAULT CURRENT ... are rejected with a syntax error, and+ * DEFAULT TODAY / DEFAULT DBSERVERNAME get rewritten by the driver into sysdefaults+ * type 'E' expression rows instead of the T / S marker rows a dbaccess-created table+ * has. Their keyword mapping is covered by+ * Gbase8sAgentTest.defaultClassKeywordMapsInformixDefaultClauseKeywords and was+ * verified against a real instance (dbaccess-created markers read back as+ * TODAY / USER / CURRENT / NULL).+ *+ * Run with DBX_TEST_GBASE8S_URL / DBX_TEST_GBASE8S_USER / DBX_TEST_GBASE8S_PASSWORD set.+ */+class Gbase8sColumnDefaultsLiveTest {+ @Test+ @EnabledIfEnvironmentVariable(named = "DBX_TEST_GBASE8S_URL", matches = ".+")+ void columnDefaultsAreDecodedAndQuotedPerColumnType() throws Exception {+ String table = "dbx_defaults_" + UUID.randomUUID().toString().replace("-", "");+ Gbase8sAgent agent = new Gbase8sAgent();+ agent.connect(new ConnectParams(+ "", 0, "", System.getenv("DBX_TEST_GBASE8S_USER"), System.getenv("DBX_TEST_GBASE8S_PASSWORD"),+ "", System.getenv("DBX_TEST_GBASE8S_URL"), false+ ));+ try (var statement = agent.getConnection().createStatement()) {+ try {+ statement.execute("CREATE TABLE " + table + " ("+ + "int_col INTEGER DEFAULT 0, "+ + "dec_col DECIMAL(10,2) DEFAULT 1.5, "+ + "vc_col VARCHAR(20) DEFAULT 'abc', "+ + "null_col INTEGER DEFAULT NULL, "+ + "expr_col INTEGER DEFAULT (1 + 2))");+ List<ColumnInfo> columns = agent.getColumns("", table);+ Map<String, String> defaults = new LinkedHashMap<>();+ for (ColumnInfo column : columns) {+ defaults.put(column.getName(), column.getColumn_default());+ }+ Assertions.assertEquals("0", defaults.get("int_col"), () -> String.valueOf(defaults));+ // The builtin decodes DECIMAL literals; the exact scale padding+ // (observed "1.5000000000" standalone, "1.5" inside the CASE)+ // is server-defined.+ Assertions.assertTrue(defaults.get("dec_col").startsWith("1.5"), () -> String.valueOf(defaults));+ Assertions.assertEquals("'abc'", defaults.get("vc_col"), () -> String.valueOf(defaults));+ Assertions.assertEquals("NULL", defaults.get("null_col"), () -> String.valueOf(defaults));+ Assertions.assertNotNull(defaults.get("expr_col"), () -> String.valueOf(defaults));+ } finally {+ try {+ statement.execute("DROP TABLE " + table);+ } catch (Exception e) {+ System.err.println("DROP failed: " + e.getMessage());+ }+ }+ } finally {+ agent.disconnect();+ }+ }+}