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(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.java
index 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");
- }
-
@Override
public 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.java
index 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 succeeds
resultSet(
@@ -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));
+ }
+
@Test
void 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 "));
+ }
+
@Test
void 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.java
new file mode 100644
index 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();
+ }
+ }
+}