fix(kingbase): load comments in MySQL compatibility mode

This commit is contained in:
amwps290 authored and GitHub committed 2026-07-22 18:11:25 +08:00
1 parent 2fa4ffd074
commit c958fc9799
5 files changed
+159 -64

No files matched your search

+41 -48
View File
@@ -229,28 +229,17 @@ func (s *server) listTables(schema string, constraints metadataListConstraints)
if !constraintsAllowsTableLike(constraints) { if !constraintsAllowsTableLike(constraints) {
return []tableInfo{}, nil return []tableInfo{}, nil
} }
var query string catalog := "sys_catalog"
if s.mode.mysqlCompat { if s.mode.postgresCatalog {
query = "SELECT table_name, table_type, CAST(NULL AS varchar(4000)) FROM information_schema.tables WHERE table_schema = " + quoteLiteral(effective) + " ORDER BY table_name" catalog = "pg_catalog"
} else { }
catalog := "sys_catalog" query := fmt.Sprintf(`SELECT c.relname,
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, 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 FROM %s.%s_class c
JOIN %s.%s_namespace n ON n.oid = c.relnamespace 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), 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), catalog, catalogPrefix(catalog), quoteLiteral(effective))
}
rows, err := s.metadataQuery(query) 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 { if err != nil {
return nil, err 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() return pageTables(result, constraints), rows.Err()
} }
func kingbaseMySQLCompatCatalogTablesQuery(schema string) string { func (s *server) getTableComment(schema, table string) (*string, error) {
return fmt.Sprintf(`SELECT c.relname, effective, err := s.effectiveSchema(schema)
CASE WHEN CAST(c.relkind AS varchar(16)) IN ('r', 'p') THEN 'TABLE' ELSE 'VIEW' END, if err != nil {
d.description return nil, err
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
} }
message := strings.ToLower(strings.Join([]string{ catalog := "sys_catalog"
kingbaseError.Message, if s.mode.postgresCatalog {
kingbaseError.Detail, catalog = "pg_catalog"
kingbaseError.Hint, }
kingbaseError.InternalQuery, prefix := catalogPrefix(catalog)
kingbaseError.Where, query := fmt.Sprintf(`SELECT obj_description(c.oid)
}, " ")) FROM %s.%s_class c
return strings.Contains(message, "sys_freespace") || strings.Contains(message, "pg_relation_size_ex") 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) { func (s *server) listObjects(schema string, constraints metadataListConstraints) ([]objectInfo, error) {
@@ -456,15 +445,14 @@ func (s *server) queryCatalogColumns(
catalog, prefix, expression string, catalog, prefix, expression string,
) ([]columnInfo, error) { ) ([]columnInfo, error) {
query := fmt.Sprintf(`SELECT a.attname, format_type(a.atttypid, a.atttypmod), NOT a.attnotnull, 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) >> 16) & 65535 END,
CASE WHEN t.typname = 'numeric' AND a.atttypmod > 0 THEN (a.atttypmod - 4) & 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 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 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 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_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, 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, catalog, prefix, quoteLiteral(schema), quoteLiteral(table))
rows, err := s.metadataQuery(query) rows, err := s.metadataQuery(query)
if err != nil { if err != nil {
return nil, err 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) { 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 query := `SELECT c.column_name, c.data_type, c.is_nullable, c.column_default,
FROM information_schema.columns WHERE table_schema = ` + quoteLiteral(schema) + ` AND table_name = ` + quoteLiteral(table) + ` ORDER BY ordinal_position` 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) rows, err := s.metadataQuery(query)
if err != nil { if err != nil {
return nil, err return nil, err
@@ -509,15 +502,15 @@ FROM information_schema.columns WHERE table_schema = ` + quoteLiteral(schema) +
result := []columnInfo{} result := []columnInfo{}
for rows.Next() { for rows.Next() {
var name, dataType, nullable string var name, dataType, nullable string
var defaultValue sql.NullString var defaultValue, comment sql.NullString
var precision, scale, length sql.NullInt64 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 return nil, err
} }
if parsed := boundedVarcharLength(dataType); parsed != nil && !length.Valid { if parsed := boundedVarcharLength(dataType); parsed != nil && !length.Valid {
length = sql.NullInt64{Int64: int64(*parsed), Valid: true} 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() return result, rows.Err()
} }
+3
View File
@@ -377,6 +377,9 @@ func (s *server) dispatch(method string, params map[string]json.RawMessage) (any
case "list_tables": case "list_tables":
result, err := s.listTables(stringParam(params, "schema"), metadataListConstraintsFromParams(params)) result, err := s.listTables(stringParam(params, "schema"), metadataListConstraintsFromParams(params))
return result, false, err 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": case "list_objects":
result, err := s.listObjects(stringParam(params, "schema"), metadataListConstraintsFromParams(params)) result, err := s.listObjects(stringParam(params, "schema"), metadataListConstraintsFromParams(params))
return result, false, err return result, false, err
+92 -16
View File
@@ -117,16 +117,22 @@ func (connection *fallbackConn) QueryContext(_ context.Context, query string, _
if strings.Contains(query, "information_schema.table_constraints") { if strings.Contains(query, "information_schema.table_constraints") {
return &valueRows{columns: []string{"column_name"}}, nil return &valueRows{columns: []string{"column_name"}}, nil
} }
if strings.Contains(query, "information_schema.tables") { if strings.Contains(query, "CASE c.relkind") && strings.Contains(query, "obj_description(c.oid)") {
return nil, &gokb.Error{
Code: gokb.ErrorCode("42501"),
Message: "permission denied for function sys_freespace",
}
}
if strings.Contains(query, "SELECT c.relname") {
return &valueRows{ return &valueRows{
columns: []string{"relname", "table_type", "description"}, columns: []string{"table_name", "table_type", "table_comment"},
rows: [][]driver.Value{{"orders", "TABLE", "orders table"}}, 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 }, nil
} }
if strings.Contains(query, "sys_get_expr(") { if strings.Contains(query, "sys_get_expr(") {
@@ -340,13 +346,17 @@ func TestColumnsFallbackToPgGetExprAndCacheChoice(t *testing.T) {
if strings.Contains(query, "pg_get_expr(") { if strings.Contains(query, "pg_get_expr(") {
pgCalls++ 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 { if sysCalls != 1 || pgCalls != 2 {
t.Fatalf("fallback choice was not cached: sys=%d pg=%d queries=%v", sysCalls, pgCalls, state.queries) 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{}) }) registerExpressionFallbackDriver.Do(func() { sql.Register("kingbase-expression-fallback-test", fallbackDriver{}) })
state := &fallbackDriverState{} state := &fallbackDriverState{}
expressionFallbackState.Store(state) expressionFallbackState.Store(state)
@@ -356,22 +366,88 @@ func TestListTablesFallsBackForSysFreespacePermission(t *testing.T) {
} }
db.SetMaxOpenConns(1) db.SetMaxOpenConns(1)
t.Cleanup(func() { _ = db.Close() }) t.Cleanup(func() { _ = db.Close() })
server := newServer() server := newServer()
server.db = db server.db = db
server.mode.mysqlCompat = true server.mode.mysqlCompat = true
tables, err := server.listTables("public", metadataListConstraints{})
columns, err := server.getColumns("public", "orders")
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
if len(tables) != 1 || tables[0].Name != "orders" { if len(columns) != 1 || columns[0].Comment == nil || *columns[0].Comment != "primary key" {
t.Fatalf("unexpected fallback tables: %#v", tables) t.Fatalf("unexpected columns: %#v", columns)
} }
state.mu.Lock() state.mu.Lock()
defer state.mu.Unlock() 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") { if len(state.queries) != 2 || !strings.Contains(state.queries[1], "col_description(a.attrelid, a.attnum)") {
t.Fatalf("unexpected fallback query sequence: %v", state.queries) 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)
} }
} }
+17
View File
@@ -1130,6 +1130,23 @@ impl AgentDriverClient {
.await .await
} }
pub async fn get_table_comment<T: DeserializeOwned + Send + 'static>(
&mut self,
database: &str,
schema: &str,
table: &str,
timeout_duration: Option<Duration>,
) -> Result<T, String> {
// 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<T: DeserializeOwned + Send + 'static>( pub async fn list_indexes<T: DeserializeOwned + Send + 'static>(
&mut self, &mut self,
database: &str, database: &str,
+6
View File
@@ -1303,6 +1303,12 @@ pub async fn get_table_comment_core(
.await?; .await?;
return oracle_table_comment_from_query_result(result); 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::<Option<String>>(database, schema, table, timeout).await;
}
} }
} }