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(grid): support Kingbase table editing and primary key resolution
lxk9551aca6286dac6
diff --git a/.github/scripts/ci-config.mjs b/.github/scripts/ci-config.mjsindex 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.goindex 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 = truedefault:return false@@ -2217,7 +2218,7 @@ ix.indexrelid, %s, %s(ix.indpred, ix.indrelid), ix.indoptionFROM %s.%s_index ix JOIN %s.%s_class t ON t.oid = ix.indrelidJOIN %s.%s_class i ON i.oid = ix.indexrelid JOIN %s.%s_namespace n ON n.oid = t.relnamespaceJOIN %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, expressioname := 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 strinquery := fmt.Sprintf(`SELECT a.attnum, a.attnameFROM %s.%s_attribute a JOIN %s.%s_class c ON c.oid = a.attrelidJOIN %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.relamJOIN unnest(ix.indkey) WITH ORDINALITY AS pos(attnum,n) ON trueLEFT 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 tcJOIN 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 stringif 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.goindex 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.vueindex 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.tsindex 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);