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(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.go
index 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 = true
return 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 bool
var 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] = item
order = 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.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`, 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, ca
name, kind string
unique, primary bool
attributeNums []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.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
JOIN 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.go
index 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 bool
infoUdtNameUnsupported bool
indexOrdinalityUnsupported bool
+ indexKeyCountUnsupported bool
triggerPrettyUnsupported bool
triggerInternalUnsupported bool
constraintDefinitionUnsupported bool
@@ -494,6 +495,7 @@ func (s *server) connect(cp connectParams) error {
s.infoColumnTypeUnsupported = false
s.infoUdtNameUnsupported = false
s.indexOrdinalityUnsupported = false
+ s.indexKeyCountUnsupported = false
s.triggerPrettyUnsupported = false
s.triggerInternalUnsupported = false
s.constraintDefinitionUnsupported = false
@@ -695,6 +697,7 @@ func (s *server) disconnect() error {
s.infoColumnTypeUnsupported = false
s.infoUdtNameUnsupported = false
s.indexOrdinalityUnsupported = false
+ s.indexKeyCountUnsupported = false
s.triggerPrettyUnsupported = false
s.triggerInternalUnsupported = false
s.constraintDefinitionUnsupported = false
diff --git a/agents/drivers/kingbase-go/main_test.go b/agents/drivers/kingbase-go/main_test.go
index 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"},
},
}, nil
case 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.go
new file mode 100644
index 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.rs
index 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