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(kingbase): preserve structured index semantics across catalogs (#12806)
Hand Sonic86aaca91ef6c
diff --git a/agents/drivers/kingbase-go/kingbase_metadata.go b/agents/drivers/kingbase-go/kingbase_metadata.goindex 0c9f9911dd..3905c2e702 100644--- a/agents/drivers/kingbase-go/kingbase_metadata.go+++ b/agents/drivers/kingbase-go/kingbase_metadata.go@@ -162,6 +162,8 @@ type indexInfo struct {IndexType *string `json:"index_type"`IncludedColumns []string `json:"included_columns"`Comment *string `json:"comment"`+ KeyIsExpression []bool `json:"key_is_expression,omitempty"`+ KeyOptions []int `json:"key_options,omitempty"`}func (i indexInfo) MarshalJSON() ([]byte, error) {@@ -2143,11 +2145,15 @@ func (s *server) listIndexes(schema, table string) ([]indexInfo, error) {if s.indexOrdinalityUnsupported {return s.listIndexesWithoutOrdinality(catalog, prefix, effective, table)}- rows, err := s.metadataQuery(kingbaseListIndexesQuery(catalog, prefix, effective, table))+ keyCount, expression := s.indexMetadataExpressions(catalog)+ rows, err := s.metadataQuery(kingbaseListIndexesQuery(catalog, prefix, effective, table, keyCount, expression))if err != nil && isUnsupportedWithOrdinality(err) {s.indexOrdinalityUnsupported = truereturn s.listIndexesWithoutOrdinality(catalog, prefix, effective, table)}+ if err != nil && s.cacheMissingIndexMetadataCapability(err) {+ return s.listIndexes(effective, table)+ }if err != nil {return nil, err}@@ -2155,19 +2161,37 @@ func (s *server) listIndexes(schema, table string) ([]indexInfo, error) {byName := map[string]*indexInfo{}order := []string{}for rows.Next() {- var name, kind, column string- var unique, primary bool+ var name, kind string+ var column, filter sql.NullString+ var unique, primary, isExpression, included boolvar ordinal int- if err := rows.Scan(&name, &kind, &unique, &primary, &column, &ordinal); err != nil {+ var rawOptions any+ if err := rows.Scan(&name, &kind, &unique, &primary, &column, &ordinal, &isExpression, &included, &filter, &rawOptions); err != nil {return nil, err}+ if !column.Valid || column.String == "" || (isExpression && strings.TrimSpace(column.String) == "") {+ return nil, fmt.Errorf("index %q has no definition for key %d", name, ordinal)+ }item := byName[name]if item == nil {- item = &indexInfo{Name: name, IsUnique: unique, IsPrimary: primary, IndexType: stringPtr(kind), Columns: []string{}, IncludedColumns: []string{}}+ item = &indexInfo{Name: name, IsUnique: unique, IsPrimary: primary, IndexType: stringPtr(kind), Filter: nullStringPtr(filter), Columns: []string{}, IncludedColumns: []string{}}byName[name] = itemorder = append(order, name)}- item.Columns = append(item.Columns, column)+ if included {+ item.IncludedColumns = append(item.IncludedColumns, column.String)+ } else {+ options, err := parseCatalogAttributeNumbers(rawOptions)+ if err != nil {+ return nil, fmt.Errorf("failed to parse index %q key options: %w", name, err)+ }+ if ordinal < 1 || ordinal > len(options) {+ return nil, fmt.Errorf("index %q has %d options for key %d", name, len(options), ordinal)+ }+ item.Columns = append(item.Columns, column.String)+ item.KeyIsExpression = append(item.KeyIsExpression, isExpression)+ item.KeyOptions = append(item.KeyOptions, options[ordinal-1])+ }}result := make([]indexInfo, 0, len(order))for _, name := range order {@@ -2176,6 +2200,30 @@ func (s *server) listIndexes(schema, table string) ([]indexInfo, error) {return result, rows.Err()}+func (s *server) indexMetadataExpressions(catalog string) (keyCount, expression string) {+ keyCount = "ix.indnkeyatts"+ if s.indexKeyCountUnsupported {+ keyCount = "ix.indnatts"+ }+ expression = kingbaseCatalogFunction(catalog, "sys_get_expr", "pg_get_expr")+ if catalog != "pg_catalog" && s.usePgDefaultExpression {+ expression = "pg_get_expr"+ }+ return keyCount, expression+}++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"):+ s.usePgDefaultExpression = true+ default:+ return false+ }+ return true+}+func isUnsupportedWithOrdinality(err error) bool {if err == nil {return false@@ -2187,12 +2235,17 @@ func isUnsupportedWithOrdinality(err error) bool {}func (s *server) listIndexesWithoutOrdinality(catalog, prefix, schema, table string) ([]indexInfo, error) {- query := fmt.Sprintf(`SELECT i.relname, am.amname, ix.indisunique, ix.indisprimary, ix.indkey+ keyCount, expression := s.indexMetadataExpressions(catalog)+ query := fmt.Sprintf(`SELECT i.relname, am.amname, ix.indisunique, ix.indisprimary, ix.indkey,+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`, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, quoteLiteral(schema), quoteLiteral(table))+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))rows, err := s.metadataQuery(query)+ if err != nil && s.cacheMissingIndexMetadataCapability(err) {+ return s.listIndexesWithoutOrdinality(catalog, prefix, schema, table)+ }if err != nil {return nil, err}@@ -2201,18 +2254,29 @@ WHERE n.nspname = %s AND t.relname = %s ORDER BY i.relname`, catalog, prefix, caname, kind stringunique, primary boolattributeNums []int+ oid int64+ keyCount int+ filter sql.NullString+ options []int}rawIndexes := []rawIndex{}for rows.Next() {var item rawIndex- var raw any- if err := rows.Scan(&item.name, &item.kind, &item.unique, &item.primary, &raw); err != nil {+ var raw, rawOptions any+ if err := rows.Scan(&item.name, &item.kind, &item.unique, &item.primary, &raw, &item.oid, &item.keyCount, &item.filter, &rawOptions); err != nil {return nil, err}item.attributeNums, err = parseCatalogAttributeNumbers(raw)if err != nil {return nil, fmt.Errorf("failed to parse index %s columns: %w", item.name, err)}+ item.options, err = parseCatalogAttributeNumbers(rawOptions)+ if err != nil {+ return nil, fmt.Errorf("failed to parse index %q key options: %w", item.name, err)+ }+ if item.keyCount < 1 || item.keyCount > len(item.attributeNums) || len(item.options) < item.keyCount {+ return nil, fmt.Errorf("index %q has inconsistent metadata: %d keys, %d attributes, %d options", item.name, item.keyCount, len(item.attributeNums), len(item.options))+ }rawIndexes = append(rawIndexes, item)}if err := rows.Err(); err != nil {@@ -2227,10 +2291,25 @@ WHERE n.nspname = %s AND t.relname = %s ORDER BY i.relname`, catalog, prefix, ca}result := make([]indexInfo, 0, len(rawIndexes))for _, raw := range rawIndexes {- item := indexInfo{Name: raw.name, IsUnique: raw.unique, IsPrimary: raw.primary, IndexType: stringPtr(raw.kind), Columns: []string{}, IncludedColumns: []string{}}- for _, number := range raw.attributeNums {- if name := attributes[number]; name != "" {+ item := indexInfo{Name: raw.name, IsUnique: raw.unique, IsPrimary: raw.primary, IndexType: stringPtr(raw.kind), Filter: nullStringPtr(raw.filter), Columns: []string{}, IncludedColumns: []string{}}+ for ordinal, number := range raw.attributeNums {+ name := attributes[number]+ if number == 0 {+ definitionFunction := kingbaseCatalogFunction(catalog, "sys_get_indexdef", "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)+ }+ }+ if name == "" || (number == 0 && strings.TrimSpace(name) == "") {+ return nil, fmt.Errorf("index %q has no definition for key %d", raw.name, ordinal+1)+ }+ if ordinal >= raw.keyCount {+ item.IncludedColumns = append(item.IncludedColumns, name)+ } else {item.Columns = append(item.Columns, name)+ item.KeyIsExpression = append(item.KeyIsExpression, number == 0)+ item.KeyOptions = append(item.KeyOptions, raw.options[ordinal])}}result = append(result, item)@@ -2288,14 +2367,17 @@ WHERE n.nspname = %s AND c.relname = %s AND a.attnum > 0 AND NOT a.attisdropped`return result, rows.Err()}-func kingbaseListIndexesQuery(catalog, prefix, schema, table string) string {- return fmt.Sprintf(`SELECT i.relname, am.amname, ix.indisunique, ix.indisprimary, a.attname, pos.n+func kingbaseListIndexesQuery(catalog, prefix, schema, table, keyCount, expression string) string {+ definitionFunction := kingbaseCatalogFunction(catalog, "sys_get_indexdef", "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.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.relamJOIN unnest(ix.indkey) WITH ORDINALITY AS pos(attnum,n) ON true-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`, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, quoteLiteral(schema), quoteLiteral(table))+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))}func kingbaseCatalogFunction(catalog, sysFunction, postgresFunction string) string {diff --git a/agents/drivers/kingbase-go/main.go b/agents/drivers/kingbase-go/main.goindex 4ec70c8087..f7a98c58fa 100644--- a/agents/drivers/kingbase-go/main.go+++ b/agents/drivers/kingbase-go/main.go@@ -148,6 +148,7 @@ type server struct {infoColumnTypeUnsupported boolinfoUdtNameUnsupported boolindexOrdinalityUnsupported bool+ indexKeyCountUnsupported booltriggerPrettyUnsupported booltriggerInternalUnsupported boolconstraintDefinitionUnsupported bool@@ -494,6 +495,7 @@ func (s *server) connect(cp connectParams) error {s.infoColumnTypeUnsupported = falses.infoUdtNameUnsupported = falses.indexOrdinalityUnsupported = false+ s.indexKeyCountUnsupported = falses.triggerPrettyUnsupported = falses.triggerInternalUnsupported = falses.constraintDefinitionUnsupported = false@@ -695,6 +697,7 @@ func (s *server) disconnect() error {s.infoColumnTypeUnsupported = falses.infoUdtNameUnsupported = falses.indexOrdinalityUnsupported = false+ s.indexKeyCountUnsupported = falses.triggerPrettyUnsupported = falses.triggerInternalUnsupported = falses.constraintDefinitionUnsupported = falsediff --git a/agents/drivers/kingbase-go/main_test.go b/agents/drivers/kingbase-go/main_test.goindex 2346d7870f..caec4bfcc3 100644--- a/agents/drivers/kingbase-go/main_test.go+++ b/agents/drivers/kingbase-go/main_test.go@@ -1356,7 +1356,7 @@ func TestConnectAndTestConnectionSharePreferFallback(t *testing.T) {}func TestKingbaseListIndexesQuerySupportsSQLServerMode(t *testing.T) {- query := kingbaseListIndexesQuery("sys_catalog", "sys", "public", "orders")+ query := kingbaseListIndexesQuery("sys_catalog", "sys", "public", "orders", "ix.indnkeyatts", "sys_get_expr")if !strings.Contains(query, "unnest(ix.indkey) WITH ORDINALITY") {t.Fatalf("index query should preserve index column order without array subscripts: %s", query)}@@ -1436,10 +1436,10 @@ func TestListIndexesFallsBackWhenWithOrdinalityIsUnsupported(t *testing.T) {return nil, &gokb.Error{Code: gokb.ErrorCode("42601"), Message: `syntax error at or near "WITH ORDINALITY"`}case strings.Contains(query, "SELECT i.relname, am.amname") && strings.Contains(query, "ix.indkey"):return &valueRows{- columns: []string{"relname", "amname", "indisunique", "indisprimary", "indkey"},+ columns: []string{"relname", "amname", "indisunique", "indisprimary", "indkey", "indexrelid", "key_count", "filter", "indoption"},rows: [][]driver.Value{- {"orders_customer_idx", "btree", false, false, "2 3"},- {"orders_pkey", "btree", true, true, []byte("1")},+ {"orders_customer_idx", "btree", false, false, "2 3", int64(123), int64(2), nil, "0 0"},+ {"orders_pkey", "btree", true, true, []byte("1"), int64(124), int64(1), nil, "0"},},}, nilcase strings.Contains(query, "SELECT a.attnum, a.attname"):diff --git a/agents/drivers/kingbase-go/metadata_index_test.go b/agents/drivers/kingbase-go/metadata_index_test.gonew file mode 100644index 0000000000..d432e4d1d2--- /dev/null+++ b/agents/drivers/kingbase-go/metadata_index_test.go@@ -0,0 +1,190 @@+package main++import (+ "database/sql/driver"+ "encoding/json"+ "errors"+ "fmt"+ "strings"+ "testing"++ gokb "gitea.com/kingbase/gokb"+)++func TestIndexMetadataPreservesExpressionsIncludesAndPredicate(t *testing.T) {+ for _, legacy := range []bool{false, true} {+ for _, pgCatalog := range []bool{false, true} {+ t.Run(fmt.Sprintf("legacy=%v/pgCatalog=%v", legacy, pgCatalog), func(t *testing.T) {+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {+ switch {+ case strings.Contains(query, "WITH ORDINALITY"):+ if legacy {+ return nil, &gokb.Error{Code: "42601", Message: `syntax error at or near "WITH ORDINALITY"`}+ }+ if !strings.Contains(query, "pos.attnum = 0") {+ return &valueRows{columns: []string{"name", "type", "unique", "primary", "column", "ordinal"}, rows: [][]driver.Value{+ {"expression_idx", "btree", false, false, "id", int64(2)},+ {"expression_idx", "btree", false, false, "payload", int64(3)},+ }}, nil+ }+ if !strings.Contains(query, "LEFT JOIN ") || !strings.Contains(query, "ix.indnkeyatts") || !strings.Contains(query, "get_indexdef(ix.indexrelid, CAST(pos.n AS integer), true)") {+ return nil, errors.New("query must preserve expression rows and INCLUDE ordinals: " + query)+ }+ return &valueRows{columns: []string{"name", "type", "unique", "primary", "column", "ordinal", "expression", "included", "predicate", "options"}, rows: [][]driver.Value{+ {"expression_idx", "btree", false, false, "lower(name)", int64(1), true, false, "active = 1", "0 3"},+ {"expression_idx", "btree", false, false, "id", int64(2), false, false, "active = 1", "0 3"},+ {"expression_idx", "btree", false, false, "payload", int64(3), false, true, "active = 1", "0 3"},+ }}, nil+ case strings.Contains(query, "SELECT i.relname, am.amname"):+ columns := []string{"name", "type", "unique", "primary", "indkey"}+ values := []driver.Value{"expression_idx", "btree", false, false, "0 1 2"}+ if strings.Contains(query, "ix.indexrelid,") {+ columns = append(columns, "oid", "key_count", "predicate", "options")+ values = append(values, int64(123), int64(2), "active = 1", "0 3")+ }+ return &valueRows{columns: columns, rows: [][]driver.Value{values}}, nil+ case strings.Contains(query, "SELECT a.attnum, a.attname"):+ return &valueRows{columns: []string{"attnum", "attname"}, rows: [][]driver.Value{{int64(1), "id"}, {int64(2), "payload"}}}, nil+ case strings.Contains(query, "get_indexdef(123, 1, true)"):+ return &valueRows{columns: []string{"expression"}, rows: [][]driver.Value{{"lower(name)"}}}, nil+ default:+ return nil, errors.New("unexpected query: " + query)+ }+ }}+ srv := newServer()+ srv.db = openMetadataDB(t, state)+ srv.mode.postgresCatalog = pgCatalog+ indexes, err := srv.listIndexes("public", "orders")+ if err != nil || len(indexes) != 1 {+ t.Fatalf("unexpected indexes: %#v (%v)", indexes, err)+ }+ index := indexes[0]+ if strings.Join(index.Columns, ",") != "lower(name),id" || strings.Join(index.IncludedColumns, ",") != "payload" || index.Filter == nil || *index.Filter != "active = 1" {+ t.Fatalf("expression/INCLUDE/predicate metadata lost: %#v", index)+ }+ payload, err := json.Marshal(index)+ if err != nil {+ t.Fatal(err)+ }+ var wire struct {+ Expressions []bool `json:"key_is_expression"`+ Options []int `json:"key_options"`+ }+ if err := json.Unmarshal(payload, &wire); err != nil || len(wire.Expressions) != 2 || !wire.Expressions[0] || wire.Expressions[1] || fmt.Sprint(wire.Options) != "[0 3]" {+ t.Fatalf("aligned key metadata must survive the existing protocol: %s (%v)", payload, err)+ }+ })+ }+ }+}++func TestIndexMetadataCachesLegacyCatalogAndExpressionFallbacks(t *testing.T) {+ for _, legacy := range []bool{false, true} {+ t.Run(fmt.Sprintf("legacy=%v", legacy), func(t *testing.T) {+ var keyCountProbes, expressionProbes int+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {+ if legacy && strings.Contains(query, "WITH ORDINALITY") {+ return nil, &gokb.Error{Code: "42601", Message: `syntax error at or near "WITH ORDINALITY"`}+ }+ if strings.Contains(query, "ix.indnkeyatts") {+ keyCountProbes+++ return nil, &gokb.Error{Code: "42703", Message: "column ix.indnkeyatts does not exist"}+ }+ if strings.Contains(query, "sys_get_expr(") {+ expressionProbes+++ return nil, &gokb.Error{Code: "42883", Message: "function sys_get_expr(pg_node_tree, oid) does not exist"}+ }+ if strings.Contains(query, "SELECT a.attnum, a.attname") {+ return &valueRows{columns: []string{"number", "name"}, rows: [][]driver.Value{{int64(1), " "}}}, nil+ }+ if !strings.Contains(query, "ix.indnatts") || !strings.Contains(query, "pg_get_expr(ix.indpred, ix.indrelid)") {+ return nil, errors.New("missing legacy metadata fallback: " + query)+ }+ if legacy {+ return &valueRows{columns: []string{"name", "type", "unique", "primary", "indkey", "oid", "count", "predicate", "options"}, rows: [][]driver.Value{{"key_idx", "btree", false, false, "1", int64(123), int64(1), nil, "0"}}}, nil+ }+ return &valueRows{columns: []string{"name", "type", "unique", "primary", "column", "ordinal", "expression", "included", "predicate", "options"}, rows: [][]driver.Value{{"key_idx", "btree", false, false, " ", int64(1), false, false, nil, "0"}}}, nil+ }}+ srv := newServer()+ srv.db = openMetadataDB(t, state)+ for call := 0; call < 2; call++ {+ indexes, err := srv.listIndexes("public", "orders")+ if err != nil || len(indexes) != 1 || strings.Join(indexes[0].Columns, ",") != " " {+ t.Fatalf("legacy index metadata or quoted identifier lost: %#v (%v)", indexes, err)+ }+ }+ if keyCountProbes != 1 || expressionProbes != 1 {+ t.Fatalf("fallbacks must be cached: keyCount=%d expression=%d", keyCountProbes, expressionProbes)+ }+ if err := srv.disconnect(); err != nil || srv.indexKeyCountUnsupported || srv.indexOrdinalityUnsupported {+ t.Fatalf("index capability cache must be connection-local: %v", err)+ }+ })+ }+}++func TestIndexMetadataDoesNotSuppressQueryFailures(t *testing.T) {+ for _, legacy := range []bool{false, true} {+ for _, failure := range []error{+ &gokb.Error{Code: "42501", Message: "permission denied for column indnkeyatts"},+ errors.New("metadata connection reset"),+ } {+ t.Run(fmt.Sprintf("legacy=%v/%s", legacy, failure), func(t *testing.T) {+ state := &metadataDriverState{query: func(string) (driver.Rows, error) { return nil, failure }}+ srv := newServer()+ srv.db = openMetadataDB(t, state)+ srv.indexOrdinalityUnsupported = legacy+ _, err := srv.listIndexes("public", "orders")+ if !errors.Is(err, failure) || len(state.snapshotQueries()) != 1 || srv.indexKeyCountUnsupported || srv.usePgDefaultExpression {+ t.Fatalf("index failure must not be hidden by capability fallback: %v", err)+ }+ })+ }+ }+}++func TestIndexMetadataRejectsIncompleteDefinitions(t *testing.T) {+ for _, legacy := range []bool{false, true} {+ for _, incompleteOptions := range []bool{false, true} {+ t.Run(fmt.Sprintf("legacy=%v/incompleteOptions=%v", legacy, incompleteOptions), func(t *testing.T) {+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {+ if strings.Contains(query, "SELECT a.attnum, a.attname") {+ return &valueRows{columns: []string{"number", "name"}}, nil+ }+ if strings.Contains(query, "get_indexdef(123, 1, true)") {+ return &valueRows{columns: []string{"definition"}}, nil+ }+ options := "0"+ if incompleteOptions {+ options = ""+ }+ if legacy {+ return &valueRows{columns: []string{"name", "type", "unique", "primary", "indkey", "oid", "count", "predicate", "options"}, rows: [][]driver.Value{{"broken_idx", "btree", false, false, "0", int64(123), int64(1), nil, options}}}, nil+ }+ var definition driver.Value+ if incompleteOptions {+ definition = "lower(name)"+ }+ return &valueRows{columns: []string{"name", "type", "unique", "primary", "column", "ordinal", "expression", "included", "predicate", "options"}, rows: [][]driver.Value{{"broken_idx", "btree", false, false, definition, int64(1), true, false, nil, options}}}, nil+ }}+ srv := newServer()+ srv.db = openMetadataDB(t, state)+ srv.indexOrdinalityUnsupported = legacy+ if _, err := srv.listIndexes("public", "orders"); err == nil || !strings.Contains(err.Error(), "broken_idx") {+ t.Fatalf("incomplete index metadata must not produce a partial definition: %v", err)+ }+ })+ }+ }+}++func TestIndexExpressionProjectionUsesUnboundedText(t *testing.T) {+ for _, catalog := range []struct{ name, prefix string }{{"sys_catalog", "sys"}, {"pg_catalog", "pg"}} {+ t.Run(catalog.name, func(t *testing.T) {+ query := kingbaseListIndexesQuery(catalog.name, catalog.prefix, "public", "orders", "ix.indnkeyatts", kingbaseCatalogFunction(catalog.name, "sys_get_expr", "pg_get_expr"))+ if !strings.Contains(query, "ELSE CAST(a.attname AS text) END") {+ t.Fatalf("CASE must resolve to text, not name which truncates expression keys: %s", query)+ }+ })+ }+}diff --git a/crates/dbx-sql-schema/src/schema_diff.rs b/crates/dbx-sql-schema/src/schema_diff.rsindex f5d55cbb2a..6a144f9f3c 100644--- a/crates/dbx-sql-schema/src/schema_diff.rs+++ b/crates/dbx-sql-schema/src/schema_diff.rs@@ -9411,6 +9411,39 @@ mod tests {assert!(!sql.contains("`((case"));}+ #[test]+ fn kingbase_agent_index_metadata_survives_sync_ddl() {+ let index: IndexInfo = serde_json::from_value(serde_json::json!({+ "name": "expression_idx", "columns": ["lower(name)", "id"],+ "is_unique": false, "is_primary": false, "filter": "active = 1",+ "index_type": "btree", "included_columns": ["payload"], "comment": null,+ "key_is_expression": [true, false], "key_options": [0, 3]+ }))+ .unwrap();+ let ddl = create_index_sql("orders", &index, DatabaseType::Kingbase, Some("public"));+ assert!(ddl.contains("(lower(name) ASC NULLS LAST, \"id\" DESC NULLS FIRST)"), "{ddl}");+ assert!(ddl.contains("INCLUDE (\"payload\") WHERE active = 1"), "{ddl}");+ assert!(!ddl.contains("\"lower(name)\""), "{ddl}");+ }++ #[test]+ fn kingbase_index_ddl_keeps_long_expressions_and_non_btree_option_semantics() {+ let expression = format!("coalesce(lower(name), '{}')", "synthetic".repeat(20));+ for index_type in ["btree", "gin", "gist"] {+ let index: IndexInfo = serde_json::from_value(serde_json::json!({+ "name": "expression_idx", "columns": [expression],+ "is_unique": false, "is_primary": false, "filter": "active = 1",+ "index_type": index_type, "included_columns": [], "comment": null,+ "key_is_expression": [true], "key_options": [3]+ }))+ .unwrap();+ let ddl = create_index_sql("orders", &index, DatabaseType::Kingbase, Some("public"));+ assert!(ddl.contains(&expression), "{ddl}");+ assert_eq!(ddl.contains("DESC NULLS FIRST"), index_type == "btree", "{ddl}");+ assert!(ddl.ends_with("WHERE active = 1;"), "{ddl}");+ }+ }+#[test]fn preserves_bare_expression_in_postgres_family_unique_index_ddl() {// Regression for #6295: highgo/postgres-family expression index key parts (e.g. from