From dfdf916964d1c5f781b32f613323925df5da6a14 Mon Sep 17 00:00:00 2001 From: zipg Date: Thu, 30 Jul 2026 16:00:12 +0800 Subject: [PATCH] fix(database): handle Kingbase metadata and rename refresh --- .../drivers/kingbase-go/kingbase_metadata.go | 20 +- agents/drivers/kingbase-go/main.go | 31 +-- agents/drivers/kingbase-go/main_test.go | 59 +++++- apps/desktop/src/components/grid/DataGrid.vue | 23 ++- .../src/components/sidebar/TreeItem.vue | 2 +- .../__tests__/useDataGridActions.spec.ts | 100 ++++++++++ .../useNavigationTargets.store.spec.ts | 52 +++++ .../src/composables/useDataGridActions.ts | 8 +- .../src/composables/useNavigationTargets.ts | 8 +- .../__tests__/dataGrid/dataGridSort.spec.ts | 48 +++++ .../sidebar/dataTabOpenPolicy.spec.ts | 9 + apps/desktop/src/lib/dataGrid/dataGridSort.ts | 38 ++++ .../src/lib/sidebar/dataTabOpenPolicy.ts | 2 +- .../queryStore.tableDataRefresh.spec.ts | 187 +++++++++++++++++- .../queryStore.tableMetaRestore.spec.ts | 26 +++ apps/desktop/src/stores/queryStore.ts | 43 +++- 16 files changed, 619 insertions(+), 37 deletions(-) create mode 100644 apps/desktop/src/lib/__tests__/dataGrid/dataGridSort.spec.ts diff --git a/agents/drivers/kingbase-go/kingbase_metadata.go b/agents/drivers/kingbase-go/kingbase_metadata.go index c57e976d5e..b1981e3637 100644 --- a/agents/drivers/kingbase-go/kingbase_metadata.go +++ b/agents/drivers/kingbase-go/kingbase_metadata.go @@ -478,17 +478,25 @@ func (s *server) queryCatalogColumns( primary map[string]bool, catalog, prefix, expression string, ) ([]columnInfo, error) { + identityExpression := "a.attidentity" + if s.catalogIdentityUnsupported { + identityExpression = "CAST(NULL AS varchar(1)) AS attidentity" + } query := fmt.Sprintf(`SELECT a.attname, format_type(a.atttypid, a.atttypmod), NOT a.attnotnull, %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, - a.attidentity + %s 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 -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, identityExpression, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, quoteLiteral(schema), quoteLiteral(table)) rows, err := s.metadataQuery(query) + if err != nil && !s.catalogIdentityUnsupported && isUndefinedColumn(err, "attidentity") { + s.catalogIdentityUnsupported = true + return s.queryCatalogColumns(schema, table, primary, catalog, prefix, expression) + } if err != nil { return nil, err } @@ -521,6 +529,14 @@ func isUndefinedFunction(err error, functionName string) bool { return undefined && strings.Contains(normalized, strings.ToLower(functionName)) } +func isUndefinedColumn(err error, columnName string) bool { + var driverError *gokb.Error + undefined := errors.As(err, &driverError) && string(driverError.Code) == "42703" + normalized := strings.ToLower(err.Error()) + undefined = undefined || strings.Contains(normalized, "does not exist") || strings.Contains(normalized, "不存在") + return undefined && strings.Contains(normalized, strings.ToLower(columnName)) +} + func (s *server) informationSchemaColumns(schema, table string, primary map[string]bool) ([]columnInfo, error) { 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 diff --git a/agents/drivers/kingbase-go/main.go b/agents/drivers/kingbase-go/main.go index dbc4b9d5e7..9a03084a0c 100644 --- a/agents/drivers/kingbase-go/main.go +++ b/agents/drivers/kingbase-go/main.go @@ -129,17 +129,18 @@ type querySession struct { } type server struct { - db *sql.DB - openDatabase kingbaseDBOpener - params connectParams - mode kingbaseMode - usePgDefaultExpression bool - currentSchema string - schemaSet bool - sessions map[string]*querySession - nextSessionID uint64 - activeCancelMu sync.Mutex - activeCancel context.CancelFunc + db *sql.DB + openDatabase kingbaseDBOpener + params connectParams + mode kingbaseMode + usePgDefaultExpression bool + catalogIdentityUnsupported bool + currentSchema string + schemaSet bool + sessions map[string]*querySession + nextSessionID uint64 + activeCancelMu sync.Mutex + activeCancel context.CancelFunc } type agentSession struct { @@ -453,6 +454,7 @@ func (s *server) connect(cp connectParams) error { s.params = cp s.mode = detectKingbaseMode(db, cp.MySQLCompatMode) s.usePgDefaultExpression = false + s.catalogIdentityUnsupported = false return nil } @@ -513,14 +515,15 @@ func openDBWithSSLMode(cp connectParams, sslMode string) (*sql.DB, error) { func (s *server) disconnect() error { s.cancelActiveQuery() s.closeAllQuerySessions() + s.usePgDefaultExpression = false + s.catalogIdentityUnsupported = false + s.currentSchema = "" + s.schemaSet = false if s.db == nil { return nil } err := s.db.Close() s.db = nil - s.usePgDefaultExpression = false - s.currentSchema = "" - s.schemaSet = false return err } diff --git a/agents/drivers/kingbase-go/main_test.go b/agents/drivers/kingbase-go/main_test.go index 783c746d47..8c17b04f56 100644 --- a/agents/drivers/kingbase-go/main_test.go +++ b/agents/drivers/kingbase-go/main_test.go @@ -48,8 +48,9 @@ type fakeRows struct { } type fallbackDriverState struct { - mu sync.Mutex - queries []string + mu sync.Mutex + queries []string + rejectAttidentity bool } type fallbackDriver struct{} @@ -207,13 +208,20 @@ func (connection *fallbackConn) QueryContext(_ context.Context, query string, _ rows: [][]driver.Value{{"id", "integer", "NO", nil, "primary key", int64(32), int64(0), nil}}, }, nil } + if connection.state.rejectAttidentity && strings.Contains(query, "a.attidentity") { + return nil, &gokb.Error{Code: gokb.ErrorCode("42703"), Message: "column a.attidentity does not exist"} + } if strings.Contains(query, "sys_get_expr(") { return nil, &gokb.Error{Code: gokb.ErrorCode("42883"), Message: "function sys_get_expr(pg_node_tree, oid) does not exist"} } if strings.Contains(query, "pg_get_expr(") { + var identity driver.Value = "d" + if strings.Contains(query, "CAST(NULL AS varchar(1)) AS attidentity") { + identity = nil + } return &valueRows{ columns: []string{"column_name", "data_type", "is_nullable", "column_default", "column_comment", "numeric_precision", "numeric_scale", "character_maximum_length", "attidentity"}, - rows: [][]driver.Value{{"id", "integer", false, nil, nil, int64(32), int64(0), nil, "d"}}, + rows: [][]driver.Value{{"id", "integer", false, nil, nil, int64(32), int64(0), nil, identity}}, }, nil } return nil, errors.New("unexpected query: " + query) @@ -906,6 +914,51 @@ func TestColumnsFallbackToPgGetExprAndCacheChoice(t *testing.T) { } } +func TestColumnsFallbackWhenCatalogHasNoAttidentityAndCacheChoice(t *testing.T) { + registerExpressionFallbackDriver.Do(func() { sql.Register("kingbase-expression-fallback-test", fallbackDriver{}) }) + state := &fallbackDriverState{rejectAttidentity: true} + 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 call := 0; call < 2; call++ { + columns, err := server.getColumns("public", "orders") + if err != nil { + t.Fatal(err) + } + if len(columns) != 1 || columns[0].Extra != nil { + t.Fatalf("unexpected columns: %#v", columns) + } + } + + state.mu.Lock() + defer state.mu.Unlock() + var identityCalls, compatibleCalls, sysCalls, pgCalls int + for _, query := range state.queries { + if strings.Contains(query, "a.attidentity") { + identityCalls++ + } + if strings.Contains(query, "CAST(NULL AS varchar(1)) AS attidentity") { + compatibleCalls++ + } + if strings.Contains(query, "sys_get_expr(") { + sysCalls++ + } + if strings.Contains(query, "pg_get_expr(") { + pgCalls++ + } + } + if identityCalls != 1 || compatibleCalls != 3 || sysCalls != 2 || pgCalls != 2 { + t.Fatalf("fallback choices were not cached: identity=%d compatible=%d sys=%d pg=%d queries=%v", identityCalls, compatibleCalls, sysCalls, pgCalls, state.queries) + } +} + func TestKingbaseIdentityClausesAreExposedAndRendered(t *testing.T) { tests := []struct { name string diff --git a/apps/desktop/src/components/grid/DataGrid.vue b/apps/desktop/src/components/grid/DataGrid.vue index 6c5b4252ca..766486ec43 100644 --- a/apps/desktop/src/components/grid/DataGrid.vue +++ b/apps/desktop/src/components/grid/DataGrid.vue @@ -205,7 +205,7 @@ import { useTheme } from "@/composables/useTheme"; import { useConnectionStore } from "@/stores/connectionStore"; import { useQueryStore } from "@/stores/queryStore"; import { useSettingsStore } from "@/stores/settingsStore"; -import type { DataGridSortDirection, DataGridSortMode } from "@/lib/dataGrid/dataGridSort"; +import { simpleDataGridOrderByMatchesSort, simpleDataGridOrderByReferencesMissingColumn, type DataGridSortDirection, type DataGridSortMode } from "@/lib/dataGrid/dataGridSort"; import { DATA_GRID_COMPACT_TOPBAR_WIDTH, type DataGridReloadIntent, type DataGridToolbarActionCapability, type DataGridToolbarAutoRefreshCapability, type DataGridToolbarCopyCapability, type DataGridToolbarSaveCapability } from "@/lib/dataGrid/dataGridToolbar"; import { getTableMetadataCapabilities } from "@/lib/table/tableMetadataCapabilities"; import { getTableStructureCapabilities } from "@/lib/table/tableStructureCapabilities"; @@ -1630,6 +1630,23 @@ watch(orderByInput, (value) => { emit("update:orderByInput", value); }); +watch( + () => props.initialOrderByInput ?? "", + (value) => { + if (value !== orderByInput.value) orderByInput.value = value; + }, +); + +watch( + () => props.tableMeta?.columns.map((column) => column.name), + (columns) => { + if (!columns?.length || !simpleDataGridOrderByReferencesMissingColumn(orderByInput.value, columns)) return; + clearSort(); + orderByInput.value = ""; + }, + { immediate: true }, +); + const isApplyingWhere = ref(false); const rowStatusFilter = ref("all"); const gridRef = ref(); @@ -2571,12 +2588,12 @@ function syncOrderByInputWithSort(column: string | null, direction: "asc" | "des watch( () => [props.sortColumn, props.sortColumnIndex, props.sortDirection, props.sortMode] as const, ([column, columnIndex, direction, mode], previous) => { - const wasControlledSort = !!previous?.[0] && !!previous?.[2]; + const previousOrderWasControlled = previous?.[3] === "database" && simpleDataGridOrderByMatchesSort(orderByInput.value, previous[0], previous[2]); const isControlledSort = !!column && !!direction; setSort(column && direction ? column : null, typeof columnIndex === "number" && direction ? columnIndex : null, direction ?? "asc", mode ?? "database"); if (isControlledSort && sortMode.value === "database") { syncOrderByInputWithSort(sortCol.value, sortDir.value); - } else if (wasControlledSort) { + } else if (previousOrderWasControlled) { syncOrderByInputWithSort(null, null); } }, diff --git a/apps/desktop/src/components/sidebar/TreeItem.vue b/apps/desktop/src/components/sidebar/TreeItem.vue index 663bd11ea4..c047b1669a 100644 --- a/apps/desktop/src/components/sidebar/TreeItem.vue +++ b/apps/desktop/src/components/sidebar/TreeItem.vue @@ -1166,7 +1166,7 @@ function onKeydown(event: KeyboardEvent) { @keydown.escape.prevent="isRenamingGroup = false" @click.stop /> - {{ visibleLabel(node) }} + {{ visibleLabel(node) }}