From c958fc97992b7f3a6e4b969ead154c271693e2cc Mon Sep 17 00:00:00 2001 From: amwps290 Date: Wed, 22 Jul 2026 18:11:25 +0800 Subject: [PATCH] fix(kingbase): load comments in MySQL compatibility mode --- .../drivers/kingbase-go/kingbase_metadata.go | 89 +++++++-------- agents/drivers/kingbase-go/main.go | 3 + agents/drivers/kingbase-go/main_test.go | 108 +++++++++++++++--- crates/dbx-core/src/db/agent_driver.rs | 17 +++ crates/dbx-core/src/schema.rs | 6 + 5 files changed, 159 insertions(+), 64 deletions(-) diff --git a/agents/drivers/kingbase-go/kingbase_metadata.go b/agents/drivers/kingbase-go/kingbase_metadata.go index 9af61e02de..6a2c6f0805 100644 --- a/agents/drivers/kingbase-go/kingbase_metadata.go +++ b/agents/drivers/kingbase-go/kingbase_metadata.go @@ -229,28 +229,17 @@ func (s *server) listTables(schema string, constraints metadataListConstraints) if !constraintsAllowsTableLike(constraints) { return []tableInfo{}, nil } - var query string - if s.mode.mysqlCompat { - query = "SELECT table_name, table_type, CAST(NULL AS varchar(4000)) FROM information_schema.tables WHERE table_schema = " + quoteLiteral(effective) + " ORDER BY table_name" - } else { - catalog := "sys_catalog" - if s.mode.postgresCatalog { - catalog = "pg_catalog" - } - query = fmt.Sprintf(`SELECT c.relname, + catalog := "sys_catalog" + if s.mode.postgresCatalog { + catalog = "pg_catalog" + } + query := fmt.Sprintf(`SELECT c.relname, CASE c.relkind WHEN 'r' THEN 'TABLE' WHEN 'p' THEN 'TABLE' WHEN 'v' THEN 'VIEW' WHEN 'm' THEN 'MATERIALIZED_VIEW' WHEN 'f' THEN 'FOREIGN_TABLE' ELSE 'TABLE' END, -d.description +obj_description(c.oid) FROM %s.%s_class c JOIN %s.%s_namespace n ON n.oid = c.relnamespace -LEFT JOIN %s.%s_description d ON d.objoid = c.oid AND d.objsubid = 0 -WHERE n.nspname = %s AND c.relkind IN ('r','p','v','m','f') ORDER BY c.relname`, catalog, catalogPrefix(catalog), catalog, catalogPrefix(catalog), catalog, catalogPrefix(catalog), quoteLiteral(effective)) - } +WHERE n.nspname = %s AND c.relkind IN ('r','p','v','m','f') ORDER BY c.relname`, catalog, catalogPrefix(catalog), catalog, catalogPrefix(catalog), quoteLiteral(effective)) rows, err := s.metadataQuery(query) - if err != nil && s.mode.mysqlCompat && isSysFreespacePermissionError(err) { - // Kingbase's information_schema.tables calls sys_freespace internally; - // restricted users need the catalog query that avoids that privileged function. - rows, err = s.metadataQuery(kingbaseMySQLCompatCatalogTablesQuery(effective)) - } if err != nil { return nil, err } @@ -270,29 +259,29 @@ WHERE n.nspname = %s AND c.relkind IN ('r','p','v','m','f') ORDER BY c.relname`, return pageTables(result, constraints), rows.Err() } -func kingbaseMySQLCompatCatalogTablesQuery(schema string) string { - return fmt.Sprintf(`SELECT c.relname, -CASE WHEN CAST(c.relkind AS varchar(16)) IN ('r', 'p') THEN 'TABLE' ELSE 'VIEW' END, -d.description -FROM sys_catalog.sys_class c -JOIN sys_catalog.sys_namespace n ON n.oid = c.relnamespace -LEFT JOIN sys_catalog.sys_description d ON CAST(d.objoid AS varchar(64)) = CAST(c.oid AS varchar(64)) AND d.objsubid = 0 -WHERE n.nspname = %s AND c.relkind IN ('r', 'p', 'v', 'm', 'f') ORDER BY c.relname`, quoteLiteral(schema)) -} - -func isSysFreespacePermissionError(err error) bool { - var kingbaseError *gokb.Error - if !errors.As(err, &kingbaseError) || kingbaseError.Code != gokb.ErrorCode("42501") { - return false +func (s *server) getTableComment(schema, table string) (*string, error) { + effective, err := s.effectiveSchema(schema) + if err != nil { + return nil, err } - message := strings.ToLower(strings.Join([]string{ - kingbaseError.Message, - kingbaseError.Detail, - kingbaseError.Hint, - kingbaseError.InternalQuery, - kingbaseError.Where, - }, " ")) - return strings.Contains(message, "sys_freespace") || strings.Contains(message, "pg_relation_size_ex") + catalog := "sys_catalog" + if s.mode.postgresCatalog { + catalog = "pg_catalog" + } + prefix := catalogPrefix(catalog) + query := fmt.Sprintf(`SELECT obj_description(c.oid) +FROM %s.%s_class c +JOIN %s.%s_namespace n ON n.oid = c.relnamespace +WHERE n.nspname = %s AND c.relname = %s AND c.relkind IN ('r','p','v','m','f') +LIMIT 1`, catalog, prefix, catalog, prefix, quoteLiteral(effective), quoteLiteral(table)) + var comment sql.NullString + if err := s.requireDBQueryRow(query, &comment); err != nil { + if err == sql.ErrNoRows { + return nil, nil + } + return nil, err + } + return nullStringPtr(comment), nil } func (s *server) listObjects(schema string, constraints metadataListConstraints) ([]objectInfo, error) { @@ -456,15 +445,14 @@ func (s *server) queryCatalogColumns( catalog, prefix, expression string, ) ([]columnInfo, error) { query := fmt.Sprintf(`SELECT a.attname, format_type(a.atttypid, a.atttypmod), NOT a.attnotnull, -%s(ad.adbin, ad.adrelid), d.description, +%s(ad.adbin, ad.adrelid), col_description(a.attrelid, a.attnum), CASE WHEN t.typname = 'numeric' AND a.atttypmod > 0 THEN ((a.atttypmod - 4) >> 16) & 65535 END, CASE WHEN t.typname = 'numeric' AND a.atttypmod > 0 THEN (a.atttypmod - 4) & 65535 END, CASE WHEN t.typname IN ('varchar','bpchar') AND a.atttypmod > 0 THEN a.atttypmod - 4 END FROM %s.%s_attribute a JOIN %s.%s_type t ON t.oid = a.atttypid JOIN %s.%s_class c ON c.oid = a.attrelid JOIN %s.%s_namespace n ON n.oid = c.relnamespace LEFT JOIN %s.%s_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum -LEFT JOIN %s.%s_description d ON d.objoid = a.attrelid AND d.objsubid = a.attnum -WHERE n.nspname = %s AND c.relname = %s AND a.attnum > 0 AND NOT a.attisdropped ORDER BY a.attnum`, expression, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, quoteLiteral(schema), quoteLiteral(table)) +WHERE n.nspname = %s AND c.relname = %s AND a.attnum > 0 AND NOT a.attisdropped ORDER BY a.attnum`, expression, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, quoteLiteral(schema), quoteLiteral(table)) rows, err := s.metadataQuery(query) if err != nil { return nil, err @@ -499,8 +487,13 @@ func isUndefinedFunction(err error, functionName string) bool { } func (s *server) informationSchemaColumns(schema, table string, primary map[string]bool) ([]columnInfo, error) { - query := `SELECT column_name, data_type, is_nullable, column_default, numeric_precision, numeric_scale, character_maximum_length -FROM information_schema.columns WHERE table_schema = ` + quoteLiteral(schema) + ` AND table_name = ` + quoteLiteral(table) + ` ORDER BY ordinal_position` + query := `SELECT c.column_name, c.data_type, c.is_nullable, c.column_default, + col_description(a.attrelid, a.attnum), c.numeric_precision, c.numeric_scale, c.character_maximum_length + FROM information_schema.columns c + LEFT JOIN sys_catalog.sys_namespace n ON n.nspname = c.table_schema + LEFT JOIN sys_catalog.sys_class rel ON rel.relnamespace = n.oid AND rel.relname = c.table_name + LEFT JOIN sys_catalog.sys_attribute a ON a.attrelid = rel.oid AND a.attname = c.column_name AND a.attnum > 0 AND NOT a.attisdropped + WHERE c.table_schema = ` + quoteLiteral(schema) + ` AND c.table_name = ` + quoteLiteral(table) + ` ORDER BY c.ordinal_position` rows, err := s.metadataQuery(query) if err != nil { return nil, err @@ -509,15 +502,15 @@ FROM information_schema.columns WHERE table_schema = ` + quoteLiteral(schema) + result := []columnInfo{} for rows.Next() { var name, dataType, nullable string - var defaultValue sql.NullString + var defaultValue, comment sql.NullString var precision, scale, length sql.NullInt64 - if err := rows.Scan(&name, &dataType, &nullable, &defaultValue, &precision, &scale, &length); err != nil { + if err := rows.Scan(&name, &dataType, &nullable, &defaultValue, &comment, &precision, &scale, &length); err != nil { return nil, err } if parsed := boundedVarcharLength(dataType); parsed != nil && !length.Valid { length = sql.NullInt64{Int64: int64(*parsed), Valid: true} } - result = append(result, columnInfo{Name: name, DataType: dataType, IsNullable: strings.EqualFold(nullable, "YES"), ColumnDefault: nullStringPtr(defaultValue), IsPrimaryKey: primary[strings.ToLower(name)], NumericPrecision: nullIntPtr(precision), NumericScale: nullIntPtr(scale), CharacterMaximumLength: nullIntPtr(length)}) + result = append(result, columnInfo{Name: name, DataType: dataType, IsNullable: strings.EqualFold(nullable, "YES"), ColumnDefault: nullStringPtr(defaultValue), IsPrimaryKey: primary[strings.ToLower(name)], Comment: nullStringPtr(comment), NumericPrecision: nullIntPtr(precision), NumericScale: nullIntPtr(scale), CharacterMaximumLength: nullIntPtr(length)}) } return result, rows.Err() } diff --git a/agents/drivers/kingbase-go/main.go b/agents/drivers/kingbase-go/main.go index 93ea770a6b..1b17afee84 100644 --- a/agents/drivers/kingbase-go/main.go +++ b/agents/drivers/kingbase-go/main.go @@ -377,6 +377,9 @@ func (s *server) dispatch(method string, params map[string]json.RawMessage) (any case "list_tables": result, err := s.listTables(stringParam(params, "schema"), metadataListConstraintsFromParams(params)) return result, false, err + case "get_table_comment": + result, err := s.getTableComment(stringParam(params, "schema"), stringParam(params, "table")) + return result, false, err case "list_objects": result, err := s.listObjects(stringParam(params, "schema"), metadataListConstraintsFromParams(params)) return result, false, err diff --git a/agents/drivers/kingbase-go/main_test.go b/agents/drivers/kingbase-go/main_test.go index 74b16ba2d2..09d7d2c294 100644 --- a/agents/drivers/kingbase-go/main_test.go +++ b/agents/drivers/kingbase-go/main_test.go @@ -117,16 +117,22 @@ func (connection *fallbackConn) QueryContext(_ context.Context, query string, _ if strings.Contains(query, "information_schema.table_constraints") { return &valueRows{columns: []string{"column_name"}}, nil } - if strings.Contains(query, "information_schema.tables") { - return nil, &gokb.Error{ - Code: gokb.ErrorCode("42501"), - Message: "permission denied for function sys_freespace", - } - } - if strings.Contains(query, "SELECT c.relname") { + if strings.Contains(query, "CASE c.relkind") && strings.Contains(query, "obj_description(c.oid)") { return &valueRows{ - columns: []string{"relname", "table_type", "description"}, - rows: [][]driver.Value{{"orders", "TABLE", "orders table"}}, + columns: []string{"table_name", "table_type", "table_comment"}, + rows: [][]driver.Value{{"orders", "BASE TABLE", "orders table"}}, + }, nil + } + if strings.Contains(query, "SELECT obj_description(c.oid)") { + return &valueRows{ + columns: []string{"table_comment"}, + rows: [][]driver.Value{{"orders table"}}, + }, nil + } + if strings.Contains(query, "FROM information_schema.columns c") { + return &valueRows{ + columns: []string{"column_name", "data_type", "is_nullable", "column_default", "column_comment", "numeric_precision", "numeric_scale", "character_maximum_length"}, + rows: [][]driver.Value{{"id", "integer", "NO", nil, "primary key", int64(32), int64(0), nil}}, }, nil } if strings.Contains(query, "sys_get_expr(") { @@ -340,13 +346,17 @@ func TestColumnsFallbackToPgGetExprAndCacheChoice(t *testing.T) { if strings.Contains(query, "pg_get_expr(") { pgCalls++ } + if (strings.Contains(query, "sys_get_expr(") || strings.Contains(query, "pg_get_expr(")) && + !strings.Contains(query, "col_description(a.attrelid, a.attnum)") { + t.Fatalf("catalog columns must use PostgreSQL column comments: %s", query) + } } if sysCalls != 1 || pgCalls != 2 { t.Fatalf("fallback choice was not cached: sys=%d pg=%d queries=%v", sysCalls, pgCalls, state.queries) } } -func TestListTablesFallsBackForSysFreespacePermission(t *testing.T) { +func TestMySQLCompatColumnsUsePostgresColumnComments(t *testing.T) { registerExpressionFallbackDriver.Do(func() { sql.Register("kingbase-expression-fallback-test", fallbackDriver{}) }) state := &fallbackDriverState{} expressionFallbackState.Store(state) @@ -356,22 +366,88 @@ func TestListTablesFallsBackForSysFreespacePermission(t *testing.T) { } db.SetMaxOpenConns(1) t.Cleanup(func() { _ = db.Close() }) - server := newServer() server.db = db server.mode.mysqlCompat = true - tables, err := server.listTables("public", metadataListConstraints{}) + + columns, err := server.getColumns("public", "orders") if err != nil { t.Fatal(err) } - if len(tables) != 1 || tables[0].Name != "orders" { - t.Fatalf("unexpected fallback tables: %#v", tables) + if len(columns) != 1 || columns[0].Comment == nil || *columns[0].Comment != "primary key" { + t.Fatalf("unexpected columns: %#v", columns) } state.mu.Lock() defer state.mu.Unlock() - if len(state.queries) != 2 || !strings.Contains(state.queries[0], "information_schema.tables") || !strings.Contains(state.queries[1], "sys_catalog.sys_class") { - t.Fatalf("unexpected fallback query sequence: %v", state.queries) + if len(state.queries) != 2 || !strings.Contains(state.queries[1], "col_description(a.attrelid, a.attnum)") { + t.Fatalf("MySQL-compatible columns must use PostgreSQL column comments: %v", state.queries) + } +} + +func TestAllCompatibilityModesUsePostgresTableComments(t *testing.T) { + registerExpressionFallbackDriver.Do(func() { sql.Register("kingbase-expression-fallback-test", fallbackDriver{}) }) + state := &fallbackDriverState{} + expressionFallbackState.Store(state) + db, err := sql.Open("kingbase-expression-fallback-test", "") + if err != nil { + t.Fatal(err) + } + db.SetMaxOpenConns(1) + t.Cleanup(func() { _ = db.Close() }) + server := newServer() + server.db = db + for _, mysqlCompat := range []bool{false, true} { + state.mu.Lock() + state.queries = nil + state.mu.Unlock() + server.mode.mysqlCompat = mysqlCompat + + tables, err := server.listTables("public", metadataListConstraints{}) + if err != nil { + t.Fatal(err) + } + if len(tables) != 1 || tables[0].Comment == nil || *tables[0].Comment != "orders table" { + t.Fatalf("mysqlCompat=%v: unexpected tables: %#v", mysqlCompat, tables) + } + + state.mu.Lock() + queries := append([]string(nil), state.queries...) + state.mu.Unlock() + if len(queries) != 1 || !strings.Contains(queries[0], "obj_description(c.oid)") || + !strings.Contains(queries[0], "FROM sys_catalog.sys_class c") { + t.Fatalf("mysqlCompat=%v: table comments must share the PostgreSQL-compatible query: %v", mysqlCompat, queries) + } + } +} + +func TestGetTableCommentUsesPostgresCatalogComment(t *testing.T) { + registerExpressionFallbackDriver.Do(func() { sql.Register("kingbase-expression-fallback-test", fallbackDriver{}) }) + state := &fallbackDriverState{} + expressionFallbackState.Store(state) + db, err := sql.Open("kingbase-expression-fallback-test", "") + if err != nil { + t.Fatal(err) + } + db.SetMaxOpenConns(1) + t.Cleanup(func() { _ = db.Close() }) + server := newServer() + server.db = db + server.mode.mysqlCompat = true + + comment, err := server.getTableComment("public", "orders") + if err != nil { + t.Fatal(err) + } + if comment == nil || *comment != "orders table" { + t.Fatalf("unexpected table comment: %#v", comment) + } + + state.mu.Lock() + defer state.mu.Unlock() + if len(state.queries) != 1 || !strings.Contains(state.queries[0], "FROM sys_catalog.sys_class c") || + !strings.Contains(state.queries[0], "n.nspname = 'public'") || !strings.Contains(state.queries[0], "c.relname = 'orders'") { + t.Fatalf("table comment must use the PostgreSQL-compatible catalog query: %v", state.queries) } } diff --git a/crates/dbx-core/src/db/agent_driver.rs b/crates/dbx-core/src/db/agent_driver.rs index 0e08299a5d..ab569d88e9 100644 --- a/crates/dbx-core/src/db/agent_driver.rs +++ b/crates/dbx-core/src/db/agent_driver.rs @@ -1130,6 +1130,23 @@ impl AgentDriverClient { .await } + pub async fn get_table_comment( + &mut self, + database: &str, + schema: &str, + table: &str, + timeout_duration: Option, + ) -> Result { + // Kingbase Go exposes this driver-specific RPC without widening the common + // agent protocol contract that every SQL agent is expected to implement. + self.call_with_timeout( + "get_table_comment", + agent_schema_table_params(database, schema, table), + timeout_duration, + ) + .await + } + pub async fn list_indexes( &mut self, database: &str, diff --git a/crates/dbx-core/src/schema.rs b/crates/dbx-core/src/schema.rs index 50444d63a3..788222702e 100644 --- a/crates/dbx-core/src/schema.rs +++ b/crates/dbx-core/src/schema.rs @@ -1303,6 +1303,12 @@ pub async fn get_table_comment_core( .await?; return oracle_table_comment_from_query_result(result); } + if db_config.as_ref().is_some_and(|config| config.db_type == DatabaseType::Kingbase) { + let timeout = agent_metadata_timeout(db_config.as_ref()); + drop(connections); + let mut client = client.lock().await; + return client.get_table_comment::>(database, schema, table, timeout).await; + } } }