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(grid): support Kingbase table editing and primary key resolution

lxk9551aca6286dac6
diff --git a/.github/scripts/ci-config.mjs b/.github/scripts/ci-config.mjs
index 145da17d5e..802bb04733 100644
--- a/.github/scripts/ci-config.mjs
+++ b/.github/scripts/ci-config.mjs
@@ -13,6 +13,7 @@ export const goAgents = [
{ driver: "cassandra-go", binary: "cassandra", race: false },
{ driver: "hive-go", binary: "hive", race: false },
{ driver: "vastbase-go", binary: "vastbase", race: false },
+ { driver: "kingbase-go", binary: "kingbase", race: false },
{ driver: "neo4j-go", binary: "neo4j", race: false },
{ driver: "nebula-go", binary: "nebula", race: false },
{ driver: "iotdb", binary: "iotdb", race: false },
diff --git a/agents/drivers/kingbase-go/kingbase_metadata.go b/agents/drivers/kingbase-go/kingbase_metadata.go
index 9ddd2dc3cb..cc26703c7f 100644
--- a/agents/drivers/kingbase-go/kingbase_metadata.go
+++ b/agents/drivers/kingbase-go/kingbase_metadata.go
@@ -6,6 +6,7 @@ import (
"encoding/json"
"errors"
"fmt"
+ "log"
"regexp"
"sort"
"strconv"
@@ -2192,7 +2193,7 @@ func (s *server) cacheMissingIndexMetadataCapability(err error) bool {
switch {
case !s.indexKeyCountUnsupported && isUndefinedColumn(err, "indnkeyatts"):
s.indexKeyCountUnsupported = true
- case !s.usePgDefaultExpression && isUndefinedFunction(err, "sys_get_expr"):
+ case !s.usePgDefaultExpression && (isUndefinedFunction(err, "sys_get_expr") || isUndefinedFunction(err, "sys_get_indexdef")):
s.usePgDefaultExpression = true
default:
return false
@@ -2217,7 +2218,7 @@ ix.indexrelid, %s, %s(ix.indpred, ix.indrelid), ix.indoption
FROM %s.%s_index ix JOIN %s.%s_class t ON t.oid = ix.indrelid
JOIN %s.%s_class i ON i.oid = ix.indexrelid JOIN %s.%s_namespace n ON n.oid = t.relnamespace
JOIN %s.%s_am am ON am.oid = i.relam
-WHERE n.nspname = %s AND t.relname = %s ORDER BY i.relname`, keyCount, expression, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, quoteLiteral(schema), quoteLiteral(table))
+WHERE (n.nspname = %s OR lower(n.nspname) = lower(%s)) AND (t.relname = %s OR lower(t.relname) = lower(%s)) ORDER BY i.relname`, keyCount, expression, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, quoteLiteral(schema), quoteLiteral(schema), quoteLiteral(table), quoteLiteral(table))
rows, err := s.metadataQuery(query)
if err != nil && s.cacheMissingIndexMetadataCapability(err) {
return s.listIndexesWithoutOrdinality(catalog, prefix, schema, table)
@@ -2272,6 +2273,9 @@ WHERE n.nspname = %s AND t.relname = %s ORDER BY i.relname`, keyCount, expressio
name := attributes[number]
if number == 0 {
definitionFunction := kingbaseCatalogFunction(catalog, "sys_get_indexdef", "pg_get_indexdef")
+ if catalog != "pg_catalog" && s.usePgDefaultExpression {
+ definitionFunction = "pg_catalog.pg_get_indexdef"
+ }
query := fmt.Sprintf("SELECT %s(%d, %d, true)", definitionFunction, raw.oid, ordinal+1)
if err := s.requireDBQueryRow(query, &name); err != nil {
return nil, fmt.Errorf("failed to read index %q key %d: %w", raw.name, ordinal+1, err)
@@ -2325,7 +2329,7 @@ func (s *server) relationAttributesByNumber(catalog, prefix, schema, table strin
query := fmt.Sprintf(`SELECT a.attnum, a.attname
FROM %s.%s_attribute a JOIN %s.%s_class c ON c.oid = a.attrelid
JOIN %s.%s_namespace n ON n.oid = c.relnamespace
-WHERE n.nspname = %s AND c.relname = %s AND a.attnum > 0 AND NOT a.attisdropped`, catalog, prefix, catalog, prefix, catalog, prefix, quoteLiteral(schema), quoteLiteral(table))
+WHERE (n.nspname = %s OR lower(n.nspname) = lower(%s)) AND (c.relname = %s OR lower(c.relname) = lower(%s)) AND a.attnum > 0 AND NOT a.attisdropped`, catalog, prefix, catalog, prefix, catalog, prefix, quoteLiteral(schema), quoteLiteral(schema), quoteLiteral(table), quoteLiteral(table))
rows, err := s.metadataQuery(query)
if err != nil {
return nil, err
@@ -2345,6 +2349,9 @@ WHERE n.nspname = %s AND c.relname = %s AND a.attnum > 0 AND NOT a.attisdropped`
func kingbaseListIndexesQuery(catalog, prefix, schema, table, keyCount, expression string) string {
definitionFunction := kingbaseCatalogFunction(catalog, "sys_get_indexdef", "pg_get_indexdef")
+ if catalog != "pg_catalog" && strings.Contains(expression, "pg_get_expr") {
+ definitionFunction = "pg_catalog.pg_get_indexdef"
+ }
return fmt.Sprintf(`SELECT i.relname, am.amname, ix.indisunique, ix.indisprimary,
CASE WHEN pos.attnum = 0 THEN %s(ix.indexrelid, CAST(pos.n AS integer), true) ELSE CAST(a.attname AS text) END, pos.n,
pos.attnum = 0, pos.n > %s, %s(ix.indpred, ix.indrelid), ix.indoption
@@ -2353,7 +2360,7 @@ JOIN %s.%s_class i ON i.oid = ix.indexrelid JOIN %s.%s_namespace n ON n.oid = t.
JOIN %s.%s_am am ON am.oid = i.relam
JOIN unnest(ix.indkey) WITH ORDINALITY AS pos(attnum,n) ON true
LEFT JOIN %s.%s_attribute a ON a.attrelid = t.oid AND a.attnum = pos.attnum
-WHERE n.nspname = %s AND t.relname = %s ORDER BY i.relname, pos.n`, definitionFunction, keyCount, expression, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, quoteLiteral(schema), quoteLiteral(table))
+WHERE (n.nspname = %s OR lower(n.nspname) = lower(%s)) AND (t.relname = %s OR lower(t.relname) = lower(%s)) ORDER BY i.relname, pos.n`, definitionFunction, keyCount, expression, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, quoteLiteral(schema), quoteLiteral(schema), quoteLiteral(table), quoteLiteral(table))
}
func kingbaseCatalogFunction(catalog, sysFunction, postgresFunction string) string {
@@ -3204,21 +3211,100 @@ func (s *server) effectiveSchema(schema string) (string, error) {
func (s *server) primaryKeys(schema, table string) (map[string]bool, error) {
query := `SELECT kcu.column_name FROM information_schema.table_constraints tc
JOIN information_schema.key_column_usage kcu ON kcu.constraint_schema=tc.constraint_schema AND kcu.constraint_name=tc.constraint_name AND kcu.table_schema=tc.table_schema AND kcu.table_name=tc.table_name
-WHERE tc.table_schema=` + quoteLiteral(schema) + ` AND tc.table_name=` + quoteLiteral(table) + ` AND tc.constraint_type='PRIMARY KEY' ORDER BY kcu.ordinal_position`
+WHERE (tc.table_schema=` + quoteLiteral(schema) + ` OR lower(tc.table_schema)=lower(` + quoteLiteral(schema) + `))
+ AND (tc.table_name=` + quoteLiteral(table) + ` OR lower(tc.table_name)=lower(` + quoteLiteral(table) + `))
+ AND tc.constraint_type='PRIMARY KEY' ORDER BY kcu.ordinal_position`
rows, err := s.metadataQuery(query)
+ result := map[string]bool{}
if err != nil {
- return nil, err
+ log.Printf("[kingbase-go][primaryKeys] information_schema query failed: schema=%q table=%q err=%v", schema, table, err)
+ } else {
+ defer rows.Close()
+ for rows.Next() {
+ var name string
+ if err := rows.Scan(&name); err != nil {
+ return nil, err
+ }
+ result[strings.ToLower(name)] = true
+ }
+ if err := rows.Err(); err != nil {
+ log.Printf("[kingbase-go][primaryKeys] information_schema query failed: schema=%q table=%q err=%v", schema, table, err)
+ }
+ }
+ if len(result) > 0 {
+ return result, nil
+ }
+ s.appendCatalogPrimaryKeys(result, schema, table)
+ return result, nil
+}
+
+// appendCatalogPrimaryKeys recovers primary keys from the system catalog when
+// information_schema reports none, e.g. in MySQL-compatibility modes. indkey
+// spans key and INCLUDE columns, so only positions up to indnkeyatts count and
+// keep declaration order; older servers fall back to indnatts (they predate
+// INCLUDE columns) or to a plain ANY membership without WITH ORDINALITY.
+func (s *server) appendCatalogPrimaryKeys(result map[string]bool, schema, table string) {
+ catalog, prefix := "sys_catalog", "sys"
+ if s.mode.postgresCatalog {
+ catalog, prefix = "pg_catalog", "pg"
+ }
+ rows, err := s.metadataQuery(s.primaryKeysCatalogQuery(catalog, prefix, schema, table))
+ if err != nil {
+ retry := false
+ if !s.indexOrdinalityUnsupported && isUnsupportedWithOrdinality(err) {
+ s.indexOrdinalityUnsupported = true
+ retry = true
+ } else if s.cacheMissingIndexMetadataCapability(err) {
+ retry = true
+ }
+ if !retry {
+ log.Printf("[kingbase-go][primaryKeys] catalog fallback query failed: schema=%q table=%q err=%v", schema, table, err)
+ return
+ }
+ rows, err = s.metadataQuery(s.primaryKeysCatalogQuery(catalog, prefix, schema, table))
+ if err != nil {
+ log.Printf("[kingbase-go][primaryKeys] catalog fallback query failed: schema=%q table=%q err=%v", schema, table, err)
+ return
+ }
}
defer rows.Close()
- result := map[string]bool{}
for rows.Next() {
var name string
if err := rows.Scan(&name); err != nil {
- return nil, err
+ log.Printf("[kingbase-go][primaryKeys] catalog fallback row scan failed: schema=%q table=%q err=%v", schema, table, err)
+ return
}
result[strings.ToLower(name)] = true
}
- return result, rows.Err()
+ if err := rows.Err(); err != nil {
+ log.Printf("[kingbase-go][primaryKeys] catalog fallback query failed: schema=%q table=%q err=%v", schema, table, err)
+ }
+}
+
+func (s *server) primaryKeysCatalogQuery(catalog, prefix, schema, table string) string {
+ predicate := fmt.Sprintf(`(n.nspname = %s OR lower(n.nspname) = lower(%s))
+ AND (t.relname = %s OR lower(t.relname) = lower(%s))`, quoteLiteral(schema), quoteLiteral(schema), quoteLiteral(table), quoteLiteral(table))
+ if s.indexOrdinalityUnsupported {
+ return fmt.Sprintf(`SELECT a.attname
+FROM %s.%s_index ix
+JOIN %s.%s_class t ON t.oid = ix.indrelid
+JOIN %s.%s_namespace n ON n.oid = t.relnamespace
+JOIN %s.%s_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+WHERE %s
+ AND ix.indisprimary
+ORDER BY a.attnum`, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, predicate)
+ }
+ keyCount, _ := s.indexMetadataExpressions(catalog)
+ return fmt.Sprintf(`SELECT a.attname
+FROM %s.%s_index ix
+JOIN %s.%s_class t ON t.oid = ix.indrelid
+JOIN %s.%s_namespace n ON n.oid = t.relnamespace
+JOIN unnest(ix.indkey) WITH ORDINALITY AS k(attnum, pos) ON true
+JOIN %s.%s_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+WHERE %s
+ AND ix.indisprimary
+ AND k.pos <= %s
+ORDER BY k.pos`, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, predicate, keyCount)
}
func (s *server) applyIdentityMetadata(schema, table string, columns []columnInfo) {
diff --git a/agents/drivers/kingbase-go/main_test.go b/agents/drivers/kingbase-go/main_test.go
index d56451926d..143104d7a5 100644
--- a/agents/drivers/kingbase-go/main_test.go
+++ b/agents/drivers/kingbase-go/main_test.go
@@ -1557,6 +1557,115 @@ func TestListIndexesDoesNotFallbackForUnrelatedErrors(t *testing.T) {
}
}
+func TestPrimaryKeysFallsBackToCatalogWhenInformationSchemaIsEmpty(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ switch {
+ case strings.Contains(query, "FROM information_schema.table_constraints tc"):
+ return &valueRows{columns: []string{"column_name"}}, nil
+ case strings.Contains(query, "FROM sys_catalog.sys_index ix") && strings.Contains(query, "ix.indisprimary"):
+ return &valueRows{columns: []string{"attname"}, rows: [][]driver.Value{{"id"}}}, nil
+ default:
+ return nil, errors.New("unexpected query: " + query)
+ }
+ }}
+ server := newServer()
+ server.db = openMetadataDB(t, state)
+
+ keys, err := server.primaryKeys("lhxzztb", "basestr")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !keys["id"] {
+ t.Fatalf("catalog fallback failed to discover primary key: %#v", keys)
+ }
+}
+
+func TestPrimaryKeysCatalogFallbackSkipsIncludedColumns(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ switch {
+ case strings.Contains(query, "FROM information_schema.table_constraints tc"):
+ return &valueRows{columns: []string{"column_name"}}, nil
+ case strings.Contains(query, "FROM sys_catalog.sys_index ix") && strings.Contains(query, "ix.indisprimary"):
+ if !strings.Contains(query, "unnest(ix.indkey) WITH ORDINALITY") ||
+ !strings.Contains(query, "k.pos <= ix.indnkeyatts") ||
+ !strings.Contains(query, "ORDER BY k.pos") {
+ return nil, fmt.Errorf("catalog fallback must scope primary keys to key positions in order: %s", query)
+ }
+ // A primary key declared (b, a) INCLUDE (c) has indkey = [2 1 3]
+ // with indnkeyatts = 2, so only attnums 2 and 1 are keys, in order.
+ return &valueRows{columns: []string{"attname"}, rows: [][]driver.Value{{"b"}, {"a"}}}, nil
+ default:
+ return nil, errors.New("unexpected query: " + query)
+ }
+ }}
+ server := newServer()
+ server.db = openMetadataDB(t, state)
+
+ keys, err := server.primaryKeys("lhxzztb", "basestr")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(keys) != 2 || !keys["a"] || !keys["b"] || keys["c"] {
+ t.Fatalf("catalog fallback must not treat INCLUDE columns as primary keys: %#v", keys)
+ }
+}
+
+func TestPrimaryKeysCatalogFallbackRetriesWithoutIndnKeyAtts(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ switch {
+ case strings.Contains(query, "FROM information_schema.table_constraints tc"):
+ return &valueRows{columns: []string{"column_name"}}, nil
+ case strings.Contains(query, "FROM sys_catalog.sys_index ix") && strings.Contains(query, "indnkeyatts"):
+ return nil, &gokb.Error{Code: gokb.ErrorCode("42703"), Message: "column ix.indnkeyatts does not exist"}
+ case strings.Contains(query, "FROM sys_catalog.sys_index ix") && strings.Contains(query, "k.pos <= ix.indnatts"):
+ return &valueRows{columns: []string{"attname"}, rows: [][]driver.Value{{"id"}}}, nil
+ default:
+ return nil, errors.New("unexpected query: " + query)
+ }
+ }}
+ server := newServer()
+ server.db = openMetadataDB(t, state)
+
+ keys, err := server.primaryKeys("lhxzztb", "basestr")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !keys["id"] {
+ t.Fatalf("catalog fallback failed on servers without indnkeyatts: %#v", keys)
+ }
+ if !server.indexKeyCountUnsupported {
+ t.Fatal("catalog fallback must cache the missing indnkeyatts capability")
+ }
+}
+
+func TestPrimaryKeysCatalogFallbackWithoutOrdinality(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ switch {
+ case strings.Contains(query, "FROM information_schema.table_constraints tc"):
+ return &valueRows{columns: []string{"column_name"}}, nil
+ case strings.Contains(query, "WITH ORDINALITY"):
+ return nil, &gokb.Error{Code: gokb.ErrorCode("42601"), Message: "syntax error at or near \"ORDINALITY\" ... WITH ORDINALITY"}
+ case strings.Contains(query, "FROM sys_catalog.sys_index ix") && strings.Contains(query, "a.attnum = ANY(ix.indkey)"):
+ return &valueRows{columns: []string{"attname"}, rows: [][]driver.Value{{"id"}}}, nil
+ default:
+ return nil, errors.New("unexpected query: " + query)
+ }
+ }}
+ server := newServer()
+ server.db = openMetadataDB(t, state)
+
+ keys, err := server.primaryKeys("lhxzztb", "basestr")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !keys["id"] {
+ t.Fatalf("catalog fallback failed on servers without WITH ORDINALITY: %#v", keys)
+ }
+ if !server.indexOrdinalityUnsupported {
+ t.Fatal("catalog fallback must cache the missing WITH ORDINALITY capability")
+ }
+}
+
func TestListForeignKeysUsesCatalogForV7(t *testing.T) {
state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
switch {
@@ -4358,7 +4467,8 @@ func TestMySQLCompatColumnsUsePostgresColumnComments(t *testing.T) {
state.mu.Lock()
defer state.mu.Unlock()
- if len(state.queries) != 2 || !strings.Contains(state.queries[1], "col_description(a.attrelid, a.attnum)") {
+ if len(state.queries) != 3 || !strings.Contains(state.queries[1], "ix.indisprimary") ||
+ !strings.Contains(state.queries[2], "col_description(a.attrelid, a.attnum)") {
t.Fatalf("MySQL-compatible columns must use PostgreSQL column comments: %v", state.queries)
}
}
diff --git a/apps/desktop/src/components/layout/ContentArea.vue b/apps/desktop/src/components/layout/ContentArea.vue
index 7d6c13a3b1..63aed1f7bd 100644
--- a/apps/desktop/src/components/layout/ContentArea.vue
+++ b/apps/desktop/src/components/layout/ContentArea.vue
@@ -3507,7 +3507,7 @@ defineExpose({
:page-sql="activeTab.resultPageSql || activeTab.sql"
:loading="activeTab.isExecuting"
:busy-started-at="activeTab.isExecuting ? activeTab.queryExecutionStartedAt : undefined"
- :editable="!activeTab.tableMetaPending && (isTableDataEditable(activeEffectiveDatabaseType, activeTableMeta?.primaryKeys ?? [], activeTableMeta?.tableType) || !!influxDbV1DeleteSaveHandler)"
+ :editable="!activeTab.tableMetaPending && (isTableDataEditable(activeEffectiveDatabaseType, activeDataTabTableMeta?.primaryKeys ?? [], activeDataTabTableMeta?.tableType) || !!influxDbV1DeleteSaveHandler)"
:custom-save-handler="influxDbV1DeleteSaveHandler"
:tab-id="activeTab.id"
context="table-data"
diff --git a/apps/desktop/src/composables/__tests__/useDataGridActions.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridActions.spec.ts
index 70f85d6dd3..e425db6813 100644
--- a/apps/desktop/src/composables/__tests__/useDataGridActions.spec.ts
+++ b/apps/desktop/src/composables/__tests__/useDataGridActions.spec.ts
@@ -209,6 +209,28 @@ describe("useDataGridActions", () => {
expect(tab.tableMeta?.primaryKeys).toEqual(["id2"]);
});
+ it("keeps Kingbase table editable after manual refresh when primary keys are populated (#13128)", async () => {
+ mocks.getConfig.mockReturnValue({ id: "kingbase-1", db_type: "kingbase" });
+ const tab = tableDataTab({
+ connectionId: "kingbase-1",
+ tableMeta: {
+ schema: "lhxzztb",
+ tableName: "basestr",
+ tableType: "TABLE",
+ columns: [{ name: "id", data_type: "bigint", is_nullable: false, column_default: "nextval('lhxzztb.basestr_id_seq'::regclass)", is_primary_key: true, extra: null }],
+ primaryKeys: ["id"],
+ },
+ });
+ mocks.tabs.push(tab);
+ mocks.getColumns.mockResolvedValue([{ name: "id", data_type: "bigint", is_nullable: false, column_default: "nextval('lhxzztb.basestr_id_seq'::regclass)", is_primary_key: true, extra: null }]);
+ const actions = useDataGridActions(computed(() => tab));
+
+ await actions.onReloadData(tab.id, tab.sql, "", "", "", 100, 0, "refresh");
+
+ expect(tab.tableMeta?.primaryKeys).toEqual(["id"]);
+ await vi.waitFor(() => expect(tab.tableMetaPending).toBe(false));
+ });
+
it.each([true, false])("keeps a surviving old key read-only until index discovery settles (success=%s)", async (success) => {
const tab = reactive(tableDataTab());
mocks.tabs.push(tab);