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): list routines by prokind and identify overloads

ezrealb5de87ff1a1b
diff --git a/agents/drivers/kingbase-go/kingbase_metadata.go b/agents/drivers/kingbase-go/kingbase_metadata.go
index 0bfa2f1e86..9ddd2dc3cb 100644
--- a/agents/drivers/kingbase-go/kingbase_metadata.go
+++ b/agents/drivers/kingbase-go/kingbase_metadata.go
@@ -126,6 +126,7 @@ type objectInfo struct {
ParentSchema *string `json:"parent_schema,omitempty"`
ParentName *string `json:"parent_name,omitempty"`
Comment *string `json:"comment"`
+ Signature *string `json:"signature,omitempty"`
Valid *bool `json:"valid,omitempty"`
CustomTypeKind *string `json:"custom_type_kind,omitempty"`
HasMembers *bool `json:"has_members,omitempty"`
@@ -1671,34 +1672,11 @@ func (s *server) listObjects(schema string, constraints metadataListConstraints)
}
}
if constraintsAllowRoutines(constraints) {
- var query string
- if s.mode.mysqlCompat {
- query = fmt.Sprintf(`SELECT ROUTINE_NAME, ROUTINE_TYPE, ROUTINE_COMMENT
-FROM information_schema.routines
-WHERE ROUTINE_SCHEMA = %s
-ORDER BY ROUTINE_NAME`, quoteLiteral(effective))
- } else {
- catalog := "sys_catalog"
- function := "sys"
- if s.mode.postgresCatalog {
- catalog, function = "pg_catalog", "pg"
- }
- query = fmt.Sprintf(`SELECT p.proname, CASE WHEN p.prorettype = 2278 THEN 'PROCEDURE' ELSE 'FUNCTION' END, d.description
-FROM %s.%s_proc p JOIN %s.%s_namespace n ON n.oid = p.pronamespace
-LEFT JOIN %s.%s_description d ON d.objoid = p.oid AND d.objsubid = 0
-WHERE n.nspname = %s ORDER BY p.proname`, catalog, function, catalog, function, catalog, function, quoteLiteral(effective))
- }
- rows, queryErr := s.metadataQuery(query)
- if queryErr == nil {
- for rows.Next() {
- var name, kind string
- var comment sql.NullString
- if rows.Scan(&name, &kind, &comment) == nil {
- result = append(result, objectInfo{Name: name, ObjectType: kind, Schema: effective, Comment: nullStringPtr(comment)})
- }
- }
- _ = rows.Close()
+ routines, routineErr := s.listRoutineObjects(effective)
+ if routineErr != nil {
+ return nil, fmt.Errorf("list routines in schema %q: %w", effective, routineErr)
}
+ result = append(result, routines...)
}
if constraintsAllowTriggers(constraints) {
triggers, triggerErr := s.listTriggerObjects(effective)
@@ -2778,6 +2756,10 @@ func (s *server) getObjectSource(schema, name, objectType string) (map[string]an
}
func (s *server) getObjectSourceForRelation(schema, name, objectType, relationName string) (map[string]any, error) {
+ return s.getObjectSourceWithSignature(schema, name, objectType, relationName, nil)
+}
+
+func (s *server) getObjectSourceWithSignature(schema, name, objectType, relationName string, signature *string) (map[string]any, error) {
effective, err := s.effectiveSchema(schema)
if err != nil {
return nil, err
@@ -2789,38 +2771,7 @@ func (s *server) getObjectSourceForRelation(schema, name, objectType, relationNa
} else if kind == "MATERIALIZED_VIEW" {
source, err = s.getMaterializedViewSource(effective, name)
} else if kind == "FUNCTION" || kind == "PROCEDURE" {
- catalog, prefix, function := "sys_catalog", "sys", "sys_get_functiondef"
- if s.mode.postgresCatalog {
- catalog, prefix, function = "pg_catalog", "pg", "pg_get_functiondef"
- } else if s.usePgFunctionDefinition {
- function = "pg_get_functiondef"
- }
- querySource := func(definitionFunction string) error {
- query := fmt.Sprintf("SELECT %s(p.oid) FROM %s.%s_proc p JOIN %s.%s_namespace n ON n.oid=p.pronamespace WHERE n.nspname=%s AND p.proname=%s ORDER BY CASE WHEN p.prorettype=2278 THEN 0 ELSE 1 END LIMIT 1", definitionFunction, catalog, prefix, catalog, prefix, quoteLiteral(effective), quoteLiteral(name))
- return s.requireDBQueryRow(query, &source)
- }
- queryLegacySource := func() error {
- legacyFunction := "GET_FUNC_DDL"
- if kind == "PROCEDURE" {
- legacyFunction = "GET_PROCEDURE_DDL"
- }
- query := fmt.Sprintf("SELECT DBMS_METADATA.%s(CAST(%s AS varchar(128)), CAST(%s AS varchar(128)))", legacyFunction, quoteLiteral(name), quoteLiteral(effective))
- return s.requireDBQueryRow(query, &source)
- }
- if s.useLegacyRoutineDefinition {
- err = queryLegacySource()
- } else {
- err = querySource(function)
- if err != nil && function == "sys_get_functiondef" && isUndefinedFunction(err, function) {
- s.usePgFunctionDefinition = true
- function = "pg_get_functiondef"
- err = querySource(function)
- }
- if err != nil && !s.mode.postgresCatalog && function == "pg_get_functiondef" && isUndefinedFunction(err, function) {
- s.useLegacyRoutineDefinition = true
- err = queryLegacySource()
- }
- }
+ source, err = s.getRoutineSource(effective, name, kind, signature)
} else if kind == "TRIGGER" {
definitions, triggerErr := s.listTriggerDefinitionsFor(effective, relationName, name)
if triggerErr != nil {
diff --git a/agents/drivers/kingbase-go/main.go b/agents/drivers/kingbase-go/main.go
index f7a98c58fa..dfbe9d4437 100644
--- a/agents/drivers/kingbase-go/main.go
+++ b/agents/drivers/kingbase-go/main.go
@@ -142,6 +142,8 @@ type server struct {
usePgViewDefinition bool
usePgFunctionDefinition bool
useLegacyRoutineDefinition bool
+ routineKindUnsupported bool
+ routineIdentityFallback int
catalogIdentityUnsupported bool
catalogGeneratedUnsupported bool
catalogOIDUnsupported bool
@@ -424,7 +426,13 @@ func (s *server) dispatch(method string, params map[string]json.RawMessage) (any
result, err := s.listTriggers(stringParam(params, "schema"), stringParam(params, "table"))
return result, false, err
case "get_object_source":
- result, err := s.getObjectSourceForRelation(stringParam(params, "schema"), stringParam(params, "name"), stringParam(params, "object_type"), stringParam(params, "relation_name"))
+ var signature *string
+ if raw, ok := params["signature"]; ok {
+ if err := json.Unmarshal(raw, &signature); err != nil {
+ return nil, false, fmt.Errorf("invalid routine signature: %w", err)
+ }
+ }
+ result, err := s.getObjectSourceWithSignature(stringParam(params, "schema"), stringParam(params, "name"), stringParam(params, "object_type"), stringParam(params, "relation_name"), signature)
return result, false, err
case "get_type_details":
result, err := s.getTypeDetails(stringParam(params, "schema"), stringParam(params, "name"))
@@ -489,6 +497,8 @@ func (s *server) connect(cp connectParams) error {
s.usePgViewDefinition = false
s.usePgFunctionDefinition = false
s.useLegacyRoutineDefinition = false
+ s.routineKindUnsupported = false
+ s.routineIdentityFallback = 0
s.catalogIdentityUnsupported = false
s.catalogGeneratedUnsupported = false
s.catalogOIDUnsupported = false
@@ -691,6 +701,8 @@ func (s *server) disconnect() error {
s.usePgViewDefinition = false
s.usePgFunctionDefinition = false
s.useLegacyRoutineDefinition = false
+ s.routineKindUnsupported = false
+ s.routineIdentityFallback = 0
s.catalogIdentityUnsupported = false
s.catalogGeneratedUnsupported = false
s.catalogOIDUnsupported = false
diff --git a/agents/drivers/kingbase-go/main_test.go b/agents/drivers/kingbase-go/main_test.go
index 956810bf76..d56451926d 100644
--- a/agents/drivers/kingbase-go/main_test.go
+++ b/agents/drivers/kingbase-go/main_test.go
@@ -2673,8 +2673,8 @@ func TestListObjectsIncludesCustomTypesWhenUnfiltered(t *testing.T) {
}, nil
case strings.Contains(query, "sys_proc p"):
return &valueRows{
- columns: []string{"proname", "kind", "comment"},
- rows: [][]driver.Value{{"format_name", "FUNCTION", nil}},
+ columns: []string{"proname", "kind", "comment", "signature"},
+ rows: [][]driver.Value{{"format_name", "FUNCTION", nil, ""}},
}, nil
case strings.Contains(query, "sys_class c"):
return &valueRows{
@@ -2708,15 +2708,15 @@ func TestListObjectsIncludesCustomTypesWhenUnfiltered(t *testing.T) {
func TestListObjectsIncludesMySQLCompatRoutines(t *testing.T) {
state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
switch {
- case strings.Contains(query, "FROM information_schema.routines"):
- if !strings.Contains(query, "WHERE ROUTINE_SCHEMA = 'team''s'") {
+ case strings.Contains(query, "FROM sys_catalog.sys_proc p"):
+ if !strings.Contains(query, "n.nspname = 'team''s'") {
return nil, errors.New("routine query did not quote the schema: " + query)
}
return &valueRows{
- columns: []string{"routine_name", "routine_type", "routine_comment"},
+ columns: []string{"routine_name", "routine_type", "comment", "signature"},
rows: [][]driver.Value{
- {"format_name", "FUNCTION", "formats a name"},
- {"refresh_cache", "PROCEDURE", nil},
+ {"format_name", "FUNCTION", "formats a name", "value text"},
+ {"refresh_cache", "PROCEDURE", nil, ""},
},
}, nil
default:
@@ -2741,7 +2741,7 @@ func TestListObjectsIncludesMySQLCompatRoutines(t *testing.T) {
t.Fatalf("unexpected function: %#v", objects[1])
}
queries := state.snapshotQueries()
- if len(queries) != 1 || !strings.Contains(queries[0], "FROM information_schema.routines") {
+ if len(queries) != 1 || !strings.Contains(queries[0], "FROM sys_catalog.sys_proc p") {
t.Fatalf("expected exactly one routine query, got %v", queries)
}
}
@@ -2754,14 +2754,14 @@ func TestListObjectsFiltersSortsAndPagesMySQLCompatObjects(t *testing.T) {
columns: []string{"relname", "relkind", "comment", "parent_schema", "parent_name"},
rows: [][]driver.Value{{"match_table", "TABLE", nil, nil, nil}},
}, nil
- case strings.Contains(query, "FROM information_schema.routines"):
+ case strings.Contains(query, "FROM sys_catalog.sys_proc p"):
return &valueRows{
- columns: []string{"routine_name", "routine_type", "routine_comment"},
+ columns: []string{"routine_name", "routine_type", "comment", "signature"},
rows: [][]driver.Value{
- {"z_match_fn", "FUNCTION", nil},
- {"other_fn", "FUNCTION", nil},
- {"match_proc", "PROCEDURE", nil},
- {"a_match_fn", "FUNCTION", nil},
+ {"z_match_fn", "FUNCTION", nil, ""},
+ {"other_fn", "FUNCTION", nil, ""},
+ {"match_proc", "PROCEDURE", nil, ""},
+ {"a_match_fn", "FUNCTION", nil, ""},
},
}, nil
default:
@@ -2794,14 +2794,14 @@ func TestListObjectsFiltersMySQLCompatRoutineKindsWithoutTableScan(t *testing.T)
for _, objectType := range []string{"FUNCTION", "PROCEDURE"} {
t.Run(objectType, func(t *testing.T) {
state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
- if !strings.Contains(query, "FROM information_schema.routines") {
+ if !strings.Contains(query, "FROM sys_catalog.sys_proc p") {
return nil, errors.New("routine-only request must not scan tables: " + query)
}
return &valueRows{
- columns: []string{"routine_name", "routine_type", "routine_comment"},
+ columns: []string{"routine_name", "routine_type", "comment", "signature"},
rows: [][]driver.Value{
- {"format_name", "FUNCTION", nil},
- {"refresh_cache", "PROCEDURE", nil},
+ {"format_name", "FUNCTION", nil, ""},
+ {"refresh_cache", "PROCEDURE", nil, ""},
},
}, nil
}}
@@ -2817,7 +2817,7 @@ func TestListObjectsFiltersMySQLCompatRoutineKindsWithoutTableScan(t *testing.T)
t.Fatalf("expected only %s, got %#v", objectType, objects)
}
queries := state.snapshotQueries()
- if len(queries) != 1 || !strings.Contains(queries[0], "FROM information_schema.routines") {
+ if len(queries) != 1 || !strings.Contains(queries[0], "FROM sys_catalog.sys_proc p") {
t.Fatalf("expected one routine query, got %v", queries)
}
})
@@ -2828,7 +2828,7 @@ func TestListObjectsSkipsMySQLCompatRoutineQueryForNonRoutineConstraints(t *test
for _, objectType := range []string{"TABLE", "TYPE"} {
t.Run(objectType, func(t *testing.T) {
state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
- if strings.Contains(query, "information_schema.routines") {
+ if strings.Contains(query, "sys_proc p") || strings.Contains(query, "information_schema.routines") {
return nil, errors.New("non-routine request must not query routines: " + query)
}
if objectType == "TABLE" && strings.Contains(query, "FROM sys_catalog.sys_class c") {
@@ -2870,8 +2870,8 @@ func TestListObjectsUsesCatalogRoutinesOutsideMySQLCompat(t *testing.T) {
return nil, errors.New("unexpected query: " + query)
}
return &valueRows{
- columns: []string{"proname", "kind", "comment"},
- rows: [][]driver.Value{{"format_name", "FUNCTION", nil}},
+ columns: []string{"proname", "kind", "comment", "signature"},
+ rows: [][]driver.Value{{"format_name", "FUNCTION", nil, ""}},
}, nil
}}
server := newServer()
@@ -2972,7 +2972,8 @@ func TestListObjectsTriggerFallbackExcludesConstraintTriggers(t *testing.T) {
}
}
-func TestListObjectsKeepsTablesWhenMySQLCompatRoutineQueryFails(t *testing.T) {
+func TestListObjectsPropagatesMySQLCompatRoutineQueryFailure(t *testing.T) {
+ routineErr := errors.New("routine catalog unavailable")
state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
switch {
case strings.Contains(query, "FROM sys_catalog.sys_class c"):
@@ -2980,8 +2981,8 @@ func TestListObjectsKeepsTablesWhenMySQLCompatRoutineQueryFails(t *testing.T) {
columns: []string{"relname", "relkind", "comment", "parent_schema", "parent_name"},
rows: [][]driver.Value{{"orders", "TABLE", "orders table", nil, nil}},
}, nil
- case strings.Contains(query, "FROM information_schema.routines"):
- return nil, errors.New("routine catalog unavailable")
+ case strings.Contains(query, "FROM sys_catalog.sys_proc p"):
+ return nil, routineErr
default:
return nil, errors.New("unexpected query: " + query)
}
@@ -2991,15 +2992,12 @@ func TestListObjectsKeepsTablesWhenMySQLCompatRoutineQueryFails(t *testing.T) {
server.mode.mysqlCompat = true
objects, err := server.listObjects("public", metadataListConstraints{})
- if err != nil {
- t.Fatal(err)
- }
- if len(objects) != 1 || objects[0].Name != "orders" || objects[0].ObjectType != "TABLE" || objects[0].Comment == nil || *objects[0].Comment != "orders table" {
- t.Fatalf("table must survive a best-effort routine query failure: %#v", objects)
+ if !errors.Is(err, routineErr) || len(objects) != 0 {
+ t.Fatalf("an incomplete list must not be returned as a success: objects=%#v err=%v", objects, err)
}
queries := state.snapshotQueries()
- if len(queries) != 2 || !strings.Contains(queries[1], "FROM information_schema.routines") {
- t.Fatalf("unexpected best-effort query sequence: %v", queries)
+ if len(queries) != 2 || !strings.Contains(queries[1], "FROM sys_catalog.sys_proc p") {
+ t.Fatalf("unexpected query sequence after routine failure: %v", queries)
}
}
@@ -3099,8 +3097,8 @@ func TestListObjectsUnfilteredPropagatesCustomTypesError(t *testing.T) {
switch {
case strings.Contains(query, "sys_proc p"):
return &valueRows{
- columns: []string{"proname", "kind", "comment"},
- rows: [][]driver.Value{{"format_name", "FUNCTION", nil}},
+ columns: []string{"proname", "kind", "comment", "signature"},
+ rows: [][]driver.Value{{"format_name", "FUNCTION", nil, ""}},
}, nil
case strings.Contains(query, "sys_class c"):
return &valueRows{
@@ -3740,6 +3738,8 @@ func TestObjectSourceDoesNotFallbackOnUnrelatedErrors(t *testing.T) {
func TestObjectSourceFallsBackToV7RoutineDDLAndCachesChoice(t *testing.T) {
state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
switch {
+ case strings.Contains(query, "COUNT(*)"):
+ return &valueRows{columns: []string{"count"}, rows: [][]driver.Value{{int64(1)}}}, nil
case strings.Contains(query, "sys_get_functiondef("):
return nil, &gokb.Error{Code: gokb.ErrorCode("42883"), Message: "function SYS_GET_FUNCTIONDEF(OID) does not exist"}
case strings.Contains(query, "pg_get_functiondef("):
@@ -3767,7 +3767,7 @@ func TestObjectSourceFallsBackToV7RoutineDDLAndCachesChoice(t *testing.T) {
}
queries := state.snapshotQueries()
- if len(queries) != 4 || !strings.Contains(queries[2], "DBMS_METADATA.GET_FUNC_DDL") || !strings.Contains(queries[3], "DBMS_METADATA.GET_FUNC_DDL") || !server.useLegacyRoutineDefinition {
+ if len(queries) != 6 || !strings.Contains(queries[3], "DBMS_METADATA.GET_FUNC_DDL") || !strings.Contains(queries[5], "DBMS_METADATA.GET_FUNC_DDL") || !server.useLegacyRoutineDefinition {
t.Fatalf("V7 routine DDL choice was not cached: %v", queries)
}
}
diff --git a/agents/drivers/kingbase-go/routine_metadata.go b/agents/drivers/kingbase-go/routine_metadata.go
new file mode 100644
index 0000000000..77767e35e9
--- /dev/null
+++ b/agents/drivers/kingbase-go/routine_metadata.go
@@ -0,0 +1,205 @@
+package main
+
+import (
+ "context"
+ "database/sql"
+ "fmt"
+ "strings"
+)
+
+func (s *server) routineCatalog() (string, string) {
+ if s.mode.postgresCatalog {
+ return "pg_catalog", "pg"
+ }
+ return "sys_catalog", "sys"
+}
+
+// Retry only missing catalog capabilities. Permission, transport and scan
+// failures must not turn a partially loaded routine list into a success.
+func (s *server) routineQuery(withIdentity bool, build func(kind, filter, identity string) string) (*sql.Rows, error) {
+ return s.routineQueryContext(context.Background(), withIdentity, build)
+}
+
+func (s *server) routineQueryContext(ctx context.Context, withIdentity bool, build func(kind, filter, identity string) string) (*sql.Rows, error) {
+ db, err := s.requireDB()
+ if err != nil {
+ return nil, err
+ }
+ _, prefix := s.routineCatalog()
+ for {
+ kind := "CASE p.prokind WHEN 'p' THEN 'PROCEDURE' WHEN 'f' THEN 'FUNCTION' END"
+ filter := "p.prokind IN ('p', 'f')"
+ if s.routineKindUnsupported {
+ // Preserve the pre-prokind Kingbase catalog behavior only after the
+ // server explicitly reports that the modern discriminator is absent.
+ kind = "CASE WHEN p.prorettype = 2278 THEN 'PROCEDURE' ELSE 'FUNCTION' END"
+ filter = "true"
+ }
+ identityFunction := prefix + "_get_function_identity_arguments"
+ identity := identityFunction + "(p.oid)"
+ if s.routineIdentityFallback == 1 {
+ identityFunction = "pg_get_function_identity_arguments"
+ identity = identityFunction + "(p.oid)"
+ } else if s.routineIdentityFallback == 2 {
+ identityFunction = "oidvectortypes"
+ identity = identityFunction + "(p.proargtypes)"
+ }
+ rows, err := db.QueryContext(ctx, build(kind, filter, identity))
+ if err == nil {
+ return rows, nil
+ }
+ if !s.routineKindUnsupported && isUndefinedColumn(err, "prokind") {
+ s.routineKindUnsupported = true
+ continue
+ }
+ if withIdentity && s.routineIdentityFallback < 2 && isUndefinedFunction(err, identityFunction) {
+ if identityFunction == "sys_get_function_identity_arguments" {
+ s.routineIdentityFallback = 1
+ } else {
+ s.routineIdentityFallback = 2
+ }
+ continue
+ }
+ return nil, err
+ }
+}
+
+func (s *server) listRoutineObjects(schema string) ([]objectInfo, error) {
+ catalog, prefix := s.routineCatalog()
+ rows, err := s.routineQuery(true, func(kind, filter, identity string) string {
+ return fmt.Sprintf(`SELECT p.proname, %s, d.description, %s AS signature
+FROM %s.%s_proc p JOIN %s.%s_namespace n ON n.oid = p.pronamespace
+LEFT JOIN %s.%s_description d ON d.objoid = p.oid AND d.objsubid = 0
+WHERE n.nspname = %s AND %s ORDER BY p.proname, signature`, kind, identity, catalog, prefix, catalog, prefix, catalog, prefix, quoteLiteral(schema), filter)
+ })
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ result := []objectInfo{}
+ for rows.Next() {
+ var name, kind, signature string
+ var comment sql.NullString
+ if err := rows.Scan(&name, &kind, &comment, &signature); err != nil {
+ return nil, err
+ }
+ // Empty identifies the zero-argument overload and must survive JSON.
+ result = append(result, objectInfo{Name: name, ObjectType: kind, Schema: schema, Comment: nullStringPtr(comment), Signature: &signature})
+ }
+ if err := rows.Err(); err != nil {
+ return nil, err
+ }
+ return result, nil
+}
+
+func (s *server) getRoutineSource(schema, name, kind string, signature *string) (string, error) {
+ ctx, cancel := context.WithTimeout(context.Background(), metadataTimeout)
+ defer cancel()
+ catalog, prefix := s.routineCatalog()
+ function := prefix + "_get_functiondef"
+ if s.usePgFunctionDefinition {
+ function = "pg_get_functiondef"
+ }
+ querySource := func(definitionFunction string) (string, error) {
+ rows, err := s.routineQueryContext(ctx, signature != nil, func(kindExpression, filter, identity string) string {
+ if signature != nil {
+ filter += " AND " + identity + " = " + quoteLiteral(*signature)
+ }
+ return fmt.Sprintf("SELECT %s(p.oid) FROM %s.%s_proc p JOIN %s.%s_namespace n ON n.oid=p.pronamespace WHERE n.nspname=%s AND p.proname=%s AND (%s)=%s AND %s ORDER BY p.oid LIMIT 2", definitionFunction, catalog, prefix, catalog, prefix, quoteLiteral(schema), quoteLiteral(name), kindExpression, quoteLiteral(kind), filter)
+ })
+ if err != nil {
+ return "", err
+ }
+ defer rows.Close()
+ var source sql.NullString
+ count := 0
+ for rows.Next() {
+ if err := rows.Scan(&source); err != nil {
+ return "", err
+ }
+ count++
+ }
+ if err := rows.Err(); err != nil {
+ return "", err
+ }
+ if count > 1 {
+ return "", fmt.Errorf("routine %q.%q is ambiguous; signature is required to select an overload", schema, name)
+ }
+ if count == 0 || !source.Valid || strings.TrimSpace(source.String) == "" {
+ return "", fmt.Errorf("routine %q.%q with the requested type and signature does not exist or its source is unavailable", schema, name)
+ }
+ return source.String, nil
+ }
+ if s.useLegacyRoutineDefinition {
+ return s.getLegacyRoutineSource(ctx, schema, name, kind, signature)
+ }
+ source, err := querySource(function)
+ if err != nil && function == "sys_get_functiondef" && isUndefinedFunction(err, function) {
+ s.usePgFunctionDefinition = true
+ function = "pg_get_functiondef"
+ source, err = querySource(function)
+ }
+ if err != nil && !s.mode.postgresCatalog && function == "pg_get_functiondef" && isUndefinedFunction(err, function) {
+ s.useLegacyRoutineDefinition = true
+ return s.getLegacyRoutineSource(ctx, schema, name, kind, signature)
+ }
+ return source, err
+}
+
+func (s *server) getLegacyRoutineSource(ctx context.Context, schema, name, kind string, signature *string) (string, error) {
+ catalog, prefix := s.routineCatalog()
+ countMatches := func(matchSignature bool) (int, error) {
+ rows, err := s.routineQueryContext(ctx, matchSignature, func(kindExpression, filter, identity string) string {
+ if matchSignature {
+ filter += " AND " + identity + " = " + quoteLiteral(*signature)
+ }
+ return fmt.Sprintf("SELECT COUNT(*) FROM %s.%s_proc p JOIN %s.%s_namespace n ON n.oid=p.pronamespace WHERE n.nspname=%s AND p.proname=%s AND (%s)=%s AND %s", catalog, prefix, catalog, prefix, quoteLiteral(schema), quoteLiteral(name), kindExpression, quoteLiteral(kind), filter)
+ })
+ if err != nil {
+ return 0, err
+ }
+ defer rows.Close()
+ var count int
+ for rows.Next() {
+ if err := rows.Scan(&count); err != nil {
+ return 0, err
+ }
+ }
+ return count, rows.Err()
+ }
+ // The V7 DDL API takes only a name. Even a supplied signature cannot make
+ // that API choose between overloads, so only a unique routine is safe.
+ count, err := countMatches(false)
+ if err != nil {
+ return "", err
+ }
+ if count > 1 {
+ return "", fmt.Errorf("legacy routine source API cannot select overloaded routine %q.%q", schema, name)
+ }
+ if count == 1 && signature != nil {
+ count, err = countMatches(true)
+ if err != nil {
+ return "", err
+ }
+ }
+ if count != 1 {
+ return "", fmt.Errorf("routine %q.%q with the requested type and signature does not exist", schema, name)
+ }
+ function := "GET_FUNC_DDL"
+ if kind == "PROCEDURE" {
+ function = "GET_PROCEDURE_DDL"
+ }
+ query := fmt.Sprintf("SELECT DBMS_METADATA.%s(CAST(%s AS varchar(128)), CAST(%s AS varchar(128)))", function, quoteLiteral(name), quoteLiteral(schema))
+ var source sql.NullString
+ db, err := s.requireDB()
+ if err != nil {
+ return "", err
+ }
+ if err := db.QueryRowContext(ctx, query).Scan(&source); err != nil {
+ return "", err
+ }
+ if !source.Valid || strings.TrimSpace(source.String) == "" {
+ return "", fmt.Errorf("routine %q.%q source is unavailable", schema, name)
+ }
+ return source.String, nil
+}
diff --git a/agents/drivers/kingbase-go/routine_metadata_context_test.go b/agents/drivers/kingbase-go/routine_metadata_context_test.go
new file mode 100644
index 0000000000..728fc8af51
--- /dev/null
+++ b/agents/drivers/kingbase-go/routine_metadata_context_test.go
@@ -0,0 +1,88 @@
+package main
+
+import (
+ "context"
+ "database/sql"
+ "database/sql/driver"
+ "errors"
+ "strings"
+ "testing"
+ "time"
+
+ "gitea.com/kingbase/gokb"
+)
+
+type routineDeadlineConnector struct {
+ query func(context.Context, string) (driver.Rows, error)
+}
+
+func (connector routineDeadlineConnector) Connect(context.Context) (driver.Conn, error) {
+ return &routineDeadlineConn{query: connector.query}, nil
+}
+
+func (routineDeadlineConnector) Driver() driver.Driver { return routineDeadlineDriver{} }
+
+type routineDeadlineDriver struct{}
+
+func (routineDeadlineDriver) Open(string) (driver.Conn, error) { return nil, driver.ErrSkip }
+
+type routineDeadlineConn struct {
+ query func(context.Context, string) (driver.Rows, error)
+}
+
+func (*routineDeadlineConn) Prepare(string) (driver.Stmt, error) { return nil, driver.ErrSkip }
+func (*routineDeadlineConn) Close() error { return nil }
+func (*routineDeadlineConn) Begin() (driver.Tx, error) { return nil, driver.ErrSkip }
+func (connection *routineDeadlineConn) QueryContext(ctx context.Context, query string, _ []driver.NamedValue) (driver.Rows, error) {
+ return connection.query(ctx, query)
+}
+
+func TestRoutineSourceSharesDeadlineAcrossCapabilityAndLegacyFallbacks(t *testing.T) {
+ contexts := []context.Context{}
+ queries := []string{}
+ db := sql.OpenDB(routineDeadlineConnector{query: func(ctx context.Context, query string) (driver.Rows, error) {
+ contexts = append(contexts, ctx)
+ queries = append(queries, query)
+ if strings.Contains(query, "p.prokind") {
+ return nil, &gokb.Error{Code: gokb.ErrorCode("42703"), Message: "column p.prokind does not exist"}
+ }
+ for _, function := range []string{"sys_get_function_identity_arguments", "pg_get_function_identity_arguments", "sys_get_functiondef", "pg_get_functiondef"} {
+ if strings.Contains(query, function+"(") {
+ return nil, &gokb.Error{Code: gokb.ErrorCode("42883"), Message: "function " + function + "(oid) does not exist"}
+ }
+ }
+ if strings.Contains(query, "SELECT COUNT(*)") {
+ return &valueRows{columns: []string{"count"}, rows: [][]driver.Value{{int64(1)}}}, nil
+ }
+ if strings.Contains(query, "DBMS_METADATA.GET_PROCEDURE_DDL") {
+ return &valueRows{columns: []string{"source"}, rows: [][]driver.Value{{"CREATE PROCEDURE recovered_source"}}}, nil
+ }
+ return nil, errors.New("unexpected routine deadline probe query: " + query)
+ }})
+ db.SetMaxOpenConns(1)
+ t.Cleanup(func() { _ = db.Close() })
+ s := newServer()
+ s.db = db
+ started := time.Now()
+ source, err := s.getObjectSourceWithSignature("public", "unique_name", "PROCEDURE", "", stringPtr("value integer"))
+ finished := time.Now()
+ if err != nil || source["source"] != "CREATE PROCEDURE recovered_source" {
+ t.Fatalf("fallback chain failed before deadline verification: source=%v err=%v", source, err)
+ }
+ if len(queries) != 8 || !strings.Contains(queries[len(queries)-1], "DBMS_METADATA.GET_PROCEDURE_DDL") {
+ t.Fatalf("expected kind, identity and source fallbacks followed by legacy validation: %v", queries)
+ }
+ deadline, ok := contexts[0].Deadline()
+ if !ok || deadline.Before(started.Add(metadataTimeout)) || deadline.After(finished.Add(metadataTimeout)) {
+ t.Fatalf("routine source did not forward the metadata timeout to the driver: deadline=%v present=%v", deadline, ok)
+ }
+ for index, ctx := range contexts {
+ got, ok := ctx.Deadline()
+ if !ok || !got.Equal(deadline) || ctx.Done() != contexts[0].Done() {
+ t.Fatalf("fallback %d reset or lost the shared deadline: want=%v got=%v present=%v", index, deadline, got, ok)
+ }
+ if !errors.Is(ctx.Err(), context.Canceled) {
+ t.Fatalf("source completion did not cancel the driver context for query %d: %v", index, ctx.Err())
+ }
+ }
+}
diff --git a/agents/drivers/kingbase-go/routine_metadata_integration_test.go b/agents/drivers/kingbase-go/routine_metadata_integration_test.go
new file mode 100644
index 0000000000..eaa200848a
--- /dev/null
+++ b/agents/drivers/kingbase-go/routine_metadata_integration_test.go
@@ -0,0 +1,147 @@
+package main
+
+import (
+ "encoding/json"
+ "fmt"
+ "os"
+ "strconv"
+ "strings"
+ "testing"
+ "time"
+)
+
+func TestKingbaseRoutineMetadataIntegration(t *testing.T) {
+ host := os.Getenv("KINGBASE_TEST_HOST")
+ portText := os.Getenv("KINGBASE_TEST_PORT")
+ username := os.Getenv("KINGBASE_TEST_USERNAME")
+ if host == "" || portText == "" || username == "" {
+ t.Skip("Kingbase integration environment is not configured")
+ }
+ port, err := strconv.Atoi(portText)
+ if err != nil {
+ t.Fatal(err)
+ }
+ database := os.Getenv("KINGBASE_TEST_DATABASE")
+ if database == "" {
+ database = "test"
+ }
+ cp := connectParams{Host: host, Port: port, Database: database, Username: username, Password: os.Getenv("KINGBASE_TEST_PASSWORD")}
+ if strings.HasPrefix(host, "/") {
+ cp.URLParams = "sslmode=disable"
+ }
+ s := newServer()
+ if err := s.connect(cp); err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() { _ = s.disconnect() })
+ if s.mode.legacyV7 {
+ t.Skip("routine metadata integration requires Kingbase V8 procedure syntax")
+ }
+
+ schema := "dbx_routines_" + strconv.FormatInt(time.Now().UnixNano(), 36)
+ qualifiedSchema := quoteIdentifier(schema)
+ mustExecute(t, s, "CREATE SCHEMA "+qualifiedSchema)
+ t.Cleanup(func() {
+ for _, statement := range []string{
+ "DROP PROCEDURE IF EXISTS " + qualifiedSchema + ".no_args()",
+ "DROP PROCEDURE IF EXISTS " + qualifiedSchema + ".input_only(integer)",
+ "DROP PROCEDURE IF EXISTS " + qualifiedSchema + ".inout_value(integer)",
+ "DROP PROCEDURE IF EXISTS " + qualifiedSchema + ".two_inout(integer, text)",
+ "DROP PROCEDURE IF EXISTS " + qualifiedSchema + ".overloaded()",
+ "DROP PROCEDURE IF EXISTS " + qualifiedSchema + ".overloaded(integer)",
+ "DROP PROCEDURE IF EXISTS " + qualifiedSchema + ".overloaded(text)",
+ "DROP FUNCTION IF EXISTS " + qualifiedSchema + ".void_function()",
+ "DROP FUNCTION IF EXISTS " + qualifiedSchema + ".scalar_function()",
+ "DROP SCHEMA IF EXISTS " + qualifiedSchema,
+ } {
+ if _, err := s.executeQuery(queryOptions{SQL: statement}); err != nil {
+ t.Errorf("cleanup %s: %v", statement, err)
+ }
+ }
+ })
+ for _, definition := range []string{
+ "PROCEDURE " + qualifiedSchema + ".no_args() LANGUAGE plpgsql AS $$ BEGIN NULL; END; $$",
+ "PROCEDURE " + qualifiedSchema + ".input_only(IN value integer) LANGUAGE plpgsql AS $$ BEGIN NULL; END; $$",
+ "PROCEDURE " + qualifiedSchema + ".inout_value(INOUT value integer) LANGUAGE plpgsql AS $$ BEGIN value := value + 1; END; $$",
+ "PROCEDURE " + qualifiedSchema + ".two_inout(INOUT value integer, INOUT label text) LANGUAGE plpgsql AS $$ BEGIN value := 13046; label := 'probe'; END; $$",
+ "PROCEDURE " + qualifiedSchema + ".overloaded() LANGUAGE plpgsql AS $$ BEGIN RAISE NOTICE 'no_args_overload_marker'; END; $$",
+ "PROCEDURE " + qualifiedSchema + ".overloaded(IN value integer) LANGUAGE plpgsql AS $$ BEGIN RAISE NOTICE 'integer_overload_marker'; END; $$",
+ "PROCEDURE " + qualifiedSchema + ".overloaded(IN value text) LANGUAGE plpgsql AS $$ BEGIN RAISE NOTICE 'text_overload_marker'; END; $$",
+ "FUNCTION " + qualifiedSchema + ".void_function() RETURNS void LANGUAGE plpgsql AS $$ BEGIN NULL; END; $$",
+ "FUNCTION " + qualifiedSchema + ".scalar_function() RETURNS integer LANGUAGE sql AS $$ SELECT 13046; $$",
+ } {
+ mustExecute(t, s, "CREATE "+definition)
+ }
+ mustExecute(t, s, "COMMENT ON PROCEDURE "+qualifiedSchema+".inout_value(integer) IS 'INOUT procedure comment'")
+
+ procedures, err := s.listObjects(schema, metadataListConstraints{ObjectTypes: []string{"PROCEDURE"}})
+ if err != nil || len(procedures) != 7 {
+ t.Fatalf("expected all seven procedures, including INOUT and overloads: objects=%+v err=%v", procedures, err)
+ }
+ functions, err := s.listObjects(schema, metadataListConstraints{ObjectTypes: []string{"FUNCTION"}})
+ if err != nil || len(functions) != 2 {
+ t.Fatalf("expected scalar and void functions: objects=%+v err=%v", functions, err)
+ }
+ for _, item := range functions {
+ if item.Name != "void_function" && item.Name != "scalar_function" {
+ t.Fatalf("procedure was incorrectly classified as a function: %+v", item)
+ }
+ }
+ overloads := []objectInfo{}
+ for _, item := range procedures {
+ if item.ObjectType != "PROCEDURE" || item.Schema != schema {
+ t.Fatalf("routine type or schema was lost: %+v", item)
+ }
+ if item.Name == "inout_value" && (item.Comment == nil || *item.Comment != "INOUT procedure comment") {
+ t.Fatalf("procedure comment was lost: %+v", item)
+ }
+ if item.Name == "overloaded" {
+ overloads = append(overloads, item)
+ }
+ }
+ if len(overloads) != 3 {
+ t.Fatalf("overloaded procedures need distinct signatures: %+v", overloads)
+ }
+ if _, _, err := s.dispatch("get_object_source", map[string]json.RawMessage{
+ "schema": rawJSON(schema), "name": rawJSON("overloaded"), "object_type": rawJSON("PROCEDURE"),
+ }); err == nil || !strings.Contains(strings.ToLower(err.Error()), "ambiguous") {
+ t.Fatalf("an overloaded name without a signature must report ambiguity: %v", err)
+ }
+ markers := map[string]bool{}
+ signatures := map[string]bool{}
+ for _, item := range overloads {
+ if item.Signature == nil || signatures[*item.Signature] {
+ t.Fatalf("overload signature is missing or duplicated: %+v", item)
+ }
+ signatures[*item.Signature] = true
+ marker := "integer_overload_marker"
+ if *item.Signature == "" {
+ marker = "no_args_overload_marker"
+ } else if strings.Contains(*item.Signature, "text") {
+ marker = "text_overload_marker"
+ }
+ result, _, err := s.dispatch("get_object_source", map[string]json.RawMessage{
+ "schema": rawJSON(schema), "name": rawJSON(item.Name), "object_type": rawJSON(item.ObjectType), "signature": rawJSON(*item.Signature),
+ })
+ if err != nil {
+ t.Fatalf("source for overload %q failed: %v", *item.Signature, err)
+ }
+ source := fmt.Sprint(result.(map[string]any)["source"])
+ if !strings.Contains(source, marker) {
+ t.Fatalf("signature %q selected the wrong overload, expected %s: %s", *item.Signature, marker, source)
+ }
+ markers[marker] = true
+ }
+ if len(markers) != 3 || !signatures[""] {
+ t.Fatalf("different overload signatures did not select distinct source bodies: %v", markers)
+ }
+ first, err := s.listObjects(schema, metadataListConstraints{ObjectTypes: []string{"PROCEDURE"}, Filter: "overloaded", Limit: 1})
+ if err != nil || len(first) != 1 || first[0].Signature == nil {
+ t.Fatalf("first overload page failed: %+v err=%v", first, err)
+ }
+ second, err := s.listObjects(schema, metadataListConstraints{ObjectTypes: []string{"PROCEDURE"}, Filter: "overloaded", Limit: 1, Offset: 1})
+ if err != nil || len(second) != 1 || second[0].Signature == nil || *first[0].Signature == *second[0].Signature {
+ t.Fatalf("overload paging duplicated or lost an identity: first=%+v second=%+v err=%v", first, second, err)
+ }
+ t.Logf("verified seven procedures, two functions, comments and all three overload sources (mode=%s)", s.mode.compatibilityMode)
+}
diff --git a/agents/drivers/kingbase-go/routine_metadata_test.go b/agents/drivers/kingbase-go/routine_metadata_test.go
new file mode 100644
index 0000000000..9145287ce5
--- /dev/null
+++ b/agents/drivers/kingbase-go/routine_metadata_test.go
@@ -0,0 +1,239 @@
+package main
+
+import (
+ "database/sql/driver"
+ "errors"
+ "strings"
+ "testing"
+
+ "gitea.com/kingbase/gokb"
+)
+
+func TestRoutineMetadataUsesCatalogKindAndPreservesOverloads(t *testing.T) {
+ for _, mode := range []struct {
+ name string
+ mode kingbaseMode
+ catalog string
+ }{
+ {name: "mysql", mode: kingbaseMode{mysqlCompat: true}, catalog: "sys_catalog.sys_proc"},
+ {name: "sys", catalog: "sys_catalog.sys_proc"},
+ {name: "pg", mode: kingbaseMode{postgresCatalog: true}, catalog: "pg_catalog.pg_proc"},
+ } {
+ t.Run(mode.name, func(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ if !strings.Contains(query, "FROM "+mode.catalog+" p") || !strings.Contains(query, "p.prokind") || !strings.Contains(query, "'team''s'") {
+ return nil, errors.New("routine query lost its catalog, kind or schema: " + query)
+ }
+ if strings.Contains(strings.ToLower(query), "routine_comment") || strings.Contains(query, "prorettype") {
+ return nil, errors.New("routine query must not rely on a missing comment column or a return-type classification: " + query)
+ }
+ if !strings.Contains(query, "ORDER BY p.proname, signature") {
+ return nil, errors.New("overloads need a stable database order before paging: " + query)
+ }
+ return &valueRows{columns: []string{"name", "kind", "comment", "signature"}, rows: [][]driver.Value{
+ {"inout_procedure", "PROCEDURE", "INOUT comment", "INOUT value integer"},
+ {"overloaded", "PROCEDURE", nil, ""},
+ {"overloaded", "PROCEDURE", nil, "value integer"},
+ {"overloaded", "PROCEDURE", nil, "value text"},
+ {"void_function", "FUNCTION", nil, ""},
+ }}, nil
+ }}
+ s := newServer()
+ s.db = openMetadataDB(t, state)
+ s.mode = mode.mode
+
+ objects, err := s.listObjects("team's", metadataListConstraints{ObjectTypes: []string{"PROCEDURE", "FUNCTION"}})
+ if err != nil || len(objects) != 5 {
+ t.Fatalf("routine list failed: objects=%+v err=%v", objects, err)
+ }
+ if objects[0].Name != "inout_procedure" || objects[0].ObjectType != "PROCEDURE" || objects[0].Comment == nil || *objects[0].Comment != "INOUT comment" {
+ t.Fatalf("INOUT procedure identity/comment was lost: %+v", objects[0])
+ }
+ if objects[4].Name != "void_function" || objects[4].ObjectType != "FUNCTION" {
+ t.Fatalf("void function was classified as a procedure: %+v", objects[4])
+ }
+ for index, signature := range []string{"", "value integer", "value text"} {
+ item := objects[index+1]
+ if item.Name != "overloaded" || item.Signature == nil || *item.Signature != signature || item.Schema != "team's" {
+ t.Fatalf("overload identity/order was lost: %+v; want signature %q", item, signature)
+ }
+ }
+ page, err := s.listObjects("team's", metadataListConstraints{ObjectTypes: []string{"PROCEDURE"}, Filter: "overloaded", Limit: 1, Offset: 1})
+ if err != nil || len(page) != 1 || page[0].Signature == nil || *page[0].Signature != "value integer" {
+ t.Fatalf("overload paging was not stable: page=%+v err=%v", page, err)
+ }
+ })
+ }
+}
+
+func TestRoutineMetadataPropagatesErrors(t *testing.T) {
+ for _, test := range []struct {
+ name string
+ rows *valueRows
+ err error
+ }{
+ {name: "permission", err: &gokb.Error{Code: gokb.ErrorCode("42501"), Message: "permission denied for sys_proc"}},
+ {name: "network", err: errors.New("connection reset by peer")},
+ {name: "unrelated missing column", err: &gokb.Error{Code: gokb.ErrorCode("42703"), Message: "column unknown_column does not exist"}},
+ {name: "scan", rows: &valueRows{columns: []string{"name", "kind", "comment", "signature"}, rows: [][]driver.Value{{nil, "PROCEDURE", nil, ""}}}},
+ {name: "stream", rows: &valueRows{columns: []string{"name", "kind", "comment", "signature"}, rows: [][]driver.Value{{"first", "PROCEDURE", nil, ""}}, nextErr: errors.New("routine stream interrupted")}},
+ } {
+ t.Run(test.name, func(t *testing.T) {
+ state := &metadataDriverState{query: func(string) (driver.Rows, error) { return test.rows, test.err }}
+ s := newServer()
+ s.db = openMetadataDB(t, state)
+ s.mode.mysqlCompat = true
+ _, err := s.listObjects("public", metadataListConstraints{ObjectTypes: []string{"PROCEDURE"}})
+ if err == nil {
+ t.Fatal("routine failure was silently returned as an empty or partial list")
+ }
+ if test.err != nil && !errors.Is(err, test.err) {
+ t.Fatalf("query error was replaced: want %v, got %v", test.err, err)
+ }
+ if test.rows != nil && test.rows.nextErr != nil && !errors.Is(err, test.rows.nextErr) {
+ t.Fatalf("stream error was replaced: want %v, got %v", test.rows.nextErr, err)
+ }
+ if queries := state.snapshotQueries(); len(queries) != 1 {
+ t.Fatalf("unrelated error triggered a fallback: %v", queries)
+ }
+ })
+ }
+}
+
+func TestRoutineMetadataFallsBackOnlyWhenKindColumnIsMissing(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ if strings.Contains(query, "p.prokind") {
+ return nil, &gokb.Error{Code: gokb.ErrorCode("42703"), Message: "column p.prokind does not exist"}
+ }
+ if !strings.Contains(query, "prorettype") {
+ return nil, errors.New("legacy routine query lost its compatibility classification: " + query)
+ }
+ return &valueRows{columns: []string{"name", "kind", "comment", "signature"}, rows: [][]driver.Value{{"legacy_proc", "PROCEDURE", nil, ""}}}, nil
+ }}
+ s := newServer()
+ s.db = openMetadataDB(t, state)
+ for call := 0; call < 2; call++ {
+ objects, err := s.listObjects("public", metadataListConstraints{ObjectTypes: []string{"PROCEDURE"}})
+ if err != nil || len(objects) != 1 {
+ t.Fatalf("legacy routine fallback failed: objects=%+v err=%v", objects, err)
+ }
+ }
+ queries := state.snapshotQueries()
+ if len(queries) != 3 || strings.Contains(queries[1], "p.prokind") || strings.Contains(queries[2], "p.prokind") {
+ t.Fatalf("missing kind-column capability was not cached: %v", queries)
+ }
+}
+
+func TestRoutineMetadataCachesSignatureFunctionFallback(t *testing.T) {
+ for _, fallback := range []string{"pg", "oidvectortypes"} {
+ t.Run(fallback, func(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ for _, function := range []string{"sys_get_function_identity_arguments", "pg_get_function_identity_arguments"} {
+ if strings.Contains(query, function+"(") && (strings.HasPrefix(function, "sys_") || fallback == "oidvectortypes") {
+ return nil, &gokb.Error{Code: gokb.ErrorCode("42883"), Message: "function " + function + "(oid) does not exist"}
+ }
+ }
+ want := "pg_get_function_identity_arguments("
+ if fallback == "oidvectortypes" {
+ want = "oidvectortypes("
+ }
+ if !strings.Contains(query, want) {
+ return nil, errors.New("unexpected signature fallback: " + query)
+ }
+ return &valueRows{columns: []string{"name", "kind", "comment", "signature"}, rows: [][]driver.Value{{"overloaded", "PROCEDURE", nil, "integer"}}}, nil
+ }}
+ s := newServer()
+ s.db = openMetadataDB(t, state)
+ for call := 0; call < 2; call++ {
+ objects, err := s.listObjects("public", metadataListConstraints{ObjectTypes: []string{"PROCEDURE"}})
+ if err != nil || len(objects) != 1 || objects[0].Signature == nil || *objects[0].Signature != "integer" {
+ t.Fatalf("signature fallback failed: objects=%+v err=%v", objects, err)
+ }
+ }
+ wantQueries := 3
+ if fallback == "oidvectortypes" {
+ wantQueries = 4
+ }
+ if queries := state.snapshotQueries(); len(queries) != wantQueries {
+ t.Fatalf("signature capability fallback was not cached: %v", queries)
+ }
+ })
+ }
+}
+
+func TestRoutineSourceUsesExplicitSignatureAndDetectsAmbiguity(t *testing.T) {
+ for _, signature := range []string{"", "value integer", "value \"Type's\""} {
+ t.Run(signature, func(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ for _, fragment := range []string{"'team''s'", "'proc''s'", "p.prokind", "identity_arguments(", quoteLiteral(signature)} {
+ if !strings.Contains(query, fragment) {
+ return nil, errors.New("routine source query lost a quoted identity component: " + query)
+ }
+ }
+ return &valueRows{columns: []string{"source"}, rows: [][]driver.Value{{"selected overload"}}}, nil
+ }}
+ s := newServer()
+ s.db = openMetadataDB(t, state)
+ source, err := s.getObjectSourceWithSignature("team's", "proc's", "PROCEDURE", "", &signature)
+ if err != nil || source["source"] != "selected overload" {
+ t.Fatalf("explicit overload source failed: source=%v err=%v", source, err)
+ }
+ })
+ }
+ t.Run("missing signature", func(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ return &valueRows{columns: []string{"source"}, rows: [][]driver.Value{{"first overload"}, {"second overload"}}}, nil
+ }}
+ s := newServer()
+ s.db = openMetadataDB(t, state)
+ _, err := s.getObjectSource("public", "overloaded", "PROCEDURE")
+ if err == nil || !strings.Contains(strings.ToLower(err.Error()), "ambiguous") {
+ t.Fatalf("missing signature silently selected one overload: %v", err)
+ }
+ })
+}
+
+func TestLegacyRoutineSourceDoesNotIgnoreOverloadIdentity(t *testing.T) {
+ for _, signature := range []*string{nil, stringPtr("value integer")} {
+ t.Run("overloaded", func(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ if !strings.Contains(query, "SELECT COUNT(*)") || strings.Contains(query, "DBMS_METADATA") {
+ return nil, errors.New("legacy name-only DDL must not run for an ambiguous name: " + query)
+ }
+ return &valueRows{columns: []string{"count"}, rows: [][]driver.Value{{int64(2)}}}, nil
+ }}
+ s := newServer()
+ s.db = openMetadataDB(t, state)
+ s.useLegacyRoutineDefinition = true
+ _, err := s.getObjectSourceWithSignature("public", "overloaded", "PROCEDURE", "", signature)
+ if err == nil || !strings.Contains(err.Error(), "overloaded") {
+ t.Fatalf("legacy name-only API must reject overloaded source, got %v", err)
+ }
+ if queries := state.snapshotQueries(); len(queries) != 1 {
+ t.Fatalf("legacy fallback ignored ambiguity: %v", queries)
+ }
+ })
+ }
+ t.Run("wrong signature", func(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ if !strings.Contains(query, "SELECT COUNT(*)") || strings.Contains(query, "DBMS_METADATA") {
+ return nil, errors.New("legacy name-only DDL must not run for a mismatched signature: " + query)
+ }
+ var count int64 = 1
+ if strings.Contains(query, "identity_arguments(") {
+ count = 0
+ }
+ return &valueRows{columns: []string{"count"}, rows: [][]driver.Value{{count}}}, nil
+ }}
+ s := newServer()
+ s.db = openMetadataDB(t, state)
+ s.useLegacyRoutineDefinition = true
+ _, err := s.getObjectSourceWithSignature("public", "unique_name", "PROCEDURE", "", stringPtr("wrong_type"))
+ if err == nil || !strings.Contains(err.Error(), "does not exist") {
+ t.Fatalf("legacy fallback silently ignored the requested signature: %v", err)
+ }
+ if queries := state.snapshotQueries(); len(queries) != 2 {
+ t.Fatalf("unexpected signature validation queries: %v", queries)
+ }
+ })
+}
diff --git a/apps/desktop/src/components/objects/ObjectBrowser.vue b/apps/desktop/src/components/objects/ObjectBrowser.vue
index 38e11a0598..4df93b100b 100644
--- a/apps/desktop/src/components/objects/ObjectBrowser.vue
+++ b/apps/desktop/src/components/objects/ObjectBrowser.vue
@@ -2675,6 +2675,7 @@ async function buildDropSqlForRow(row: ObjectBrowserRow, options?: { cascade?: b
objectType: row.type,
schema: row.schema || selectedSchema.value,
name: row.name,
+ signature: row.signature,
identifierQuote: connectionStore.connectionIdentifierQuote?.(props.connection.id),
});
}
diff --git a/apps/desktop/src/components/objects/__tests__/ObjectBrowser.routineSourceTab.component.spec.ts b/apps/desktop/src/components/objects/__tests__/ObjectBrowser.routineSourceTab.component.spec.ts
index 6c49e094a4..c273d81572 100644
--- a/apps/desktop/src/components/objects/__tests__/ObjectBrowser.routineSourceTab.component.spec.ts
+++ b/apps/desktop/src/components/objects/__tests__/ObjectBrowser.routineSourceTab.component.spec.ts
@@ -11,6 +11,8 @@ const mocks = vi.hoisted(() => ({
listSchemas: vi.fn(),
getObjectSource: vi.fn(),
buildEditableObjectSource: vi.fn(),
+ buildDropObjectSql: vi.fn(),
+ contextMenuAction: "",
ensureConnected: vi.fn(),
openObjectSourceTabPending: vi.fn(),
toast: vi.fn(),
@@ -29,6 +31,7 @@ vi.mock("@/lib/backend/api", () => ({
listObjectStatistics: vi.fn().mockResolvedValue([]),
getObjectSource: (...args: unknown[]) => mocks.getObjectSource(...args),
buildEditableObjectSource: (...args: unknown[]) => mocks.buildEditableObjectSource(...args),
+ buildDropObjectSql: (...args: unknown[]) => mocks.buildDropObjectSql(...args),
}));
vi.mock("@/stores/connectionStore", () => ({
useConnectionStore: () => ({
@@ -69,8 +72,16 @@ vi.mock("@/components/ui/searchable-select", () => ({ SearchableSelect: { render
vi.mock("@/components/ui/ToolbarOverflowMenu.vue", () => ({ default: { render: () => null } }));
vi.mock("@/components/ui/CustomContextMenu.vue", () => ({
default: defineComponent({
- setup(_, { slots }) {
- return () => slots.default?.({ onContextMenu: () => undefined, isOpen: false });
+ props: { items: { type: [Array, Function], default: () => [] } },
+ setup(props, { slots }) {
+ return () =>
+ slots.default?.({
+ onContextMenu: () => {
+ const items = typeof props.items === "function" ? props.items() : props.items;
+ items.find((item: { label?: string }) => item.label === mocks.contextMenuAction)?.action?.();
+ },
+ isOpen: false,
+ });
},
}),
}));
@@ -97,6 +108,9 @@ const mountedApps: Array<{ app: App; host: HTMLElement }> = [];
beforeEach(() => {
vi.clearAllMocks();
+ connection.db_type = "mysql";
+ mocks.contextMenuAction = "";
+ mocks.buildDropObjectSql.mockResolvedValue('DROP PROCEDURE "app"."sp_daily_report"();');
mocks.listObjects.mockResolvedValue([
{ name: "sp_daily_report", schema: "app", object_type: "PROCEDURE", signature: "IN day DATE" },
{ name: "fn_total", schema: "app", object_type: "FUNCTION", signature: "" },
@@ -141,6 +155,27 @@ function click(row: HTMLElement, detail: number) {
}
describe("ObjectBrowser routine double click", () => {
+ it.each(["", "v integer", "v INOUT integer"])("keeps the selected Kingbase overload in its DROP preview (%j)", async (signature) => {
+ connection.db_type = "kingbase";
+ mocks.listObjects.mockResolvedValue([{ name: "sp_daily_report", schema: "app", object_type: "PROCEDURE", signature }]);
+ mocks.contextMenuAction = "contextMenu.dropProcedure";
+ const host = await mountBrowser();
+
+ rowFor(host, "sp_daily_report").dispatchEvent(new MouseEvent("contextmenu", { bubbles: true }));
+
+ await vi.waitFor(() =>
+ expect(mocks.buildDropObjectSql).toHaveBeenCalledWith(
+ expect.objectContaining({
+ databaseType: "kingbase",
+ objectType: "PROCEDURE",
+ schema: "app",
+ name: "sp_daily_report",
+ signature,
+ }),
+ ),
+ );
+ });
+
it("keeps a reopened source panel independent of the previous late response", async () => {
const host = await mountBrowser();
vi.useFakeTimers();
diff --git a/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue b/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue
index b3f24f7df7..86536c86af 100644
--- a/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue
+++ b/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue
@@ -3621,7 +3621,7 @@ function openRenameObjectDialog() {
routeTreeItemDialogController();
const node = sidebarFormTarget.value ?? activeNode.value;
const targetKey = JSON.stringify([node.connectionId, node.database, node.schema || node.database, node.type, node.objectName || node.label, databaseTypeForNode(node)]);
- if (targetKey !== currentSidebarViewRenameTargetKey) renameObjectName.value = node.label;
+ if (targetKey !== currentSidebarViewRenameTargetKey) renameObjectName.value = node.objectName || node.label;
renameObjectError.value = "";
renameObjectPreviewSql.value = "";
viewRenamePlan.value = undefined;
@@ -3732,7 +3732,7 @@ async function refreshRenameObjectPreviewSql() {
const node = sidebarFormTarget.value ?? activeNode.value;
const requestId = ++renameObjectPreviewRequestId;
const newName = renameObjectName.value.trim();
- if (!showRenameObjectDialog.value || !newName || newName === node.label) {
+ if (!showRenameObjectDialog.value || !newName || newName === (node.objectName || node.label)) {
renameObjectPreviewSql.value = "";
viewRenamePlan.value = undefined;
routineRenamePlan.value = undefined;
@@ -4050,7 +4050,7 @@ async function confirmPackageSaveAs() {
async function confirmRenameObject() {
const node = sidebarFormTarget.value ?? activeNode.value;
let newName = renameObjectName.value.trim();
- if (!newName || newName === node.label || !node.connectionId || !node.database) return;
+ if (!newName || newName === (node.objectName || node.label) || !node.connectionId || !node.database) return;
renameObjectError.value = "";
let renameApplied = false;
let updatedViewDependencies: number | undefined;
@@ -4194,7 +4194,7 @@ async function confirmRenameObject() {
databaseType: dbType!,
objectType: objectType as any,
schema,
- name: node.label,
+ name: node.objectName || node.label,
newName,
source: source.source,
});
diff --git a/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.renameCancellation.spec.ts b/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.renameCancellation.spec.ts
index ffe2fd7102..49639a28b1 100644
--- a/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.renameCancellation.spec.ts
+++ b/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.renameCancellation.spec.ts
@@ -3,6 +3,7 @@ import { createApp, defineComponent, h, nextTick, ref } from "vue";
import { createPinia, setActivePinia } from "pinia";
import { describe, expect, it, vi } from "vitest";
import i18n from "@/i18n";
+import * as api from "@/lib/backend/api";
import type { ContextMenuItem } from "@/components/ui/CustomContextMenu.vue";
import type { TreeNode } from "@/types/database";
@@ -243,4 +244,50 @@ describe("sidebar rename production cancellation", () => {
showRenameObjectDialog.value = false;
}
});
+
+ it.each(["", "v integer", "v INOUT integer"])("renames the selected Kingbase overload using its object name (%j)", async (signature) => {
+ const pinia = createPinia();
+ setActivePinia(pinia);
+ const store = useConnectionStore();
+ store.connections = [{ id: "rename-kingbase", name: "Kingbase", db_type: "kingbase", host: "localhost", port: 54321, username: "system" } as any];
+ vi.spyOn(store, "ensureConnected").mockResolvedValue(undefined);
+ const host = ref<any>();
+ let controller: any;
+ const node: TreeNode = { id: `rename-kingbase-${signature}`, type: "procedure", label: `run(${signature})`, objectName: "run", signature, connectionId: "rename-kingbase", database: "app", schema: "public" };
+ const root = defineComponent({
+ setup: () => () =>
+ h(SidebarTreeRuntimeHost, {
+ ref: host,
+ node,
+ depth: 0,
+ onOpenDialogController: (value: unknown) => {
+ controller = value;
+ },
+ }),
+ });
+ const container = document.createElement("div");
+ document.body.appendChild(container);
+ const app = createApp(root).use(pinia).use(i18n);
+ vi.mocked(api.getObjectSource).mockClear();
+ vi.mocked(api.buildRoutineRenameObjectSourceStatements).mockClear();
+ try {
+ app.mount(container);
+ await nextTick();
+ const items: ContextMenuItem[] = host.value.buildContextMenu(node);
+ items.find((item) => item.label === i18n.global.t("contextMenu.renameObject"))!.action!();
+ expect(renameObjectName.value).toBe("run");
+ await controller.confirmRenameObject();
+ expect(api.getObjectSource).not.toHaveBeenCalled();
+ expect(api.buildRoutineRenameObjectSourceStatements).not.toHaveBeenCalled();
+ renameObjectName.value = "run_new";
+ await nextTick();
+ await controller.confirmRenameObject();
+ expect(api.getObjectSource).toHaveBeenCalledWith("rename-kingbase", "app", "public", "run", "PROCEDURE", signature);
+ expect(api.buildRoutineRenameObjectSourceStatements).toHaveBeenCalledWith(expect.objectContaining({ databaseType: "kingbase", name: "run", newName: "run_new" }));
+ } finally {
+ app.unmount();
+ container.remove();
+ showRenameObjectDialog.value = false;
+ }
+ });
});
diff --git a/apps/desktop/src/lib/__tests__/table/tableTree.spec.ts b/apps/desktop/src/lib/__tests__/table/tableTree.spec.ts
index 67a4f3095e..43c51a9587 100644
--- a/apps/desktop/src/lib/__tests__/table/tableTree.spec.ts
+++ b/apps/desktop/src/lib/__tests__/table/tableTree.spec.ts
@@ -14,6 +14,7 @@ import {
} from "@/lib/table/tableTree";
import type { ObjectInfo, TableInfo, TreeNode } from "@/types/database";
import { decorateDatabaseSavedSqlTreeNodes } from "@/lib/savedSql/savedSqlDatabaseTree";
+import { objectSourceTargetForTreeNode } from "@/lib/sidebar/treeNodeClick";
const context = {
nodeId: "connection:db",
@@ -214,6 +215,42 @@ describe("PostgreSQL overloaded routines", () => {
});
});
+describe("Kingbase overloaded procedures", () => {
+ it.each(["simple", "grouped"] as const)("keeps missing routine signatures and empty non-routine signatures absent in the %s tree", (layout) => {
+ const objects: ObjectInfo[] = [
+ { name: "unknown", object_type: "PROCEDURE", schema: "app", signature: null },
+ { name: "orders_view", object_type: "VIEW", schema: "app", signature: "" },
+ { name: "orders_seq", object_type: "SEQUENCE", schema: "app", signature: "" },
+ ];
+ const options = { ...context, schema: "app", objects, databaseType: "kingbase" as const };
+ const nodes = layout === "simple" ? buildSimpleObjectTreeNodes(options) : buildGroupedObjectTreeNodes(options).flatMap((group) => group.children ?? []);
+
+ expect(nodes).toHaveLength(3);
+ expect(nodes.every((node) => node.signature === undefined)).toBe(true);
+ });
+
+ it.each(["simple", "grouped"] as const)("preserves overloads and the zero-argument signature in the %s tree", (layout) => {
+ const objects: ObjectInfo[] = [
+ { name: "run", object_type: "PROCEDURE", schema: "app", signature: "" },
+ { name: "run", object_type: "PROCEDURE", schema: "app", signature: "v integer" },
+ { name: "run", object_type: "PROCEDURE", schema: "app", signature: "v text" },
+ { name: "run", object_type: "PROCEDURE", schema: "app", signature: "v text" },
+ ];
+ const options = { ...context, schema: "app", objects, databaseType: "kingbase" as const };
+ const nodes = layout === "simple" ? buildSimpleObjectTreeNodes(options) : buildGroupedObjectTreeNodes(options).find((node) => node.type === "group-procedures")!.children!;
+
+ expect(nodes).toHaveLength(3);
+ expect(new Set(nodes.map((node) => node.id)).size).toBe(3);
+ expect(nodes.map(objectSourceTargetForTreeNode)).toEqual(
+ expect.arrayContaining([
+ { name: "run", schema: "app", objectType: "PROCEDURE", signature: "" },
+ { name: "run", schema: "app", objectType: "PROCEDURE", signature: "v integer" },
+ { name: "run", schema: "app", objectType: "PROCEDURE", signature: "v text" },
+ ]),
+ );
+ });
+});
+
describe("PostgreSQL custom type metadata", () => {
it("preserves type kind and member capability in simple and grouped trees", () => {
const objects: ObjectInfo[] = [
diff --git a/apps/desktop/src/lib/table/tableTree.ts b/apps/desktop/src/lib/table/tableTree.ts
index adcdbe274d..65b622c725 100644
--- a/apps/desktop/src/lib/table/tableTree.ts
+++ b/apps/desktop/src/lib/table/tableTree.ts
@@ -723,7 +723,7 @@ export function buildSimpleObjectTreeNodes({ nodeId, connectionId, database, sch
label: signature && (objectType === "FUNCTION" || objectType === "PROCEDURE") ? `${name}(${signature})` : triggerParentName ? `${name} (${triggerParentName})` : name,
type: simpleNodeType,
objectName: name,
- signature: signature || undefined,
+ signature: objectType === "FUNCTION" || objectType === "PROCEDURE" ? (obj.signature == null ? undefined : signature) : signature || undefined,
customTypeKind: obj.custom_type_kind ?? undefined,
hasMembers: obj.has_members ?? undefined,
comment: obj.comment,
@@ -985,7 +985,7 @@ export function buildGroupedObjectTreeNodes({ nodeId, connectionId, database, sc
label: signature && (objectType === "FUNCTION" || objectType === "PROCEDURE") ? `${obj.name}(${signature})` : triggerParentName ? `${obj.name} (${triggerParentName})` : obj.name,
type: childType,
objectName: obj.name,
- signature: signature || undefined,
+ signature: objectType === "FUNCTION" || objectType === "PROCEDURE" ? (obj.signature == null ? undefined : signature) : signature || undefined,
customTypeKind: obj.custom_type_kind ?? undefined,
hasMembers: obj.has_members ?? undefined,
comment: obj.comment,
diff --git a/apps/desktop/src/stores/__tests__/connectionStore.metadataLoading.spec.ts b/apps/desktop/src/stores/__tests__/connectionStore.metadataLoading.spec.ts
index fb69bb26bc..2af5d86c5a 100644
--- a/apps/desktop/src/stores/__tests__/connectionStore.metadataLoading.spec.ts
+++ b/apps/desktop/src/stores/__tests__/connectionStore.metadataLoading.spec.ts
@@ -2136,6 +2136,51 @@ describe("connectionStore metadata loading", () => {
expect(storedProcedureGroup?.children?.map((node) => node.label)).toEqual(["p_0999"]);
});
+ it("keeps Kingbase procedure overloads and zero-argument identities across pages", async () => {
+ const objects: ObjectInfo[] = [
+ ...Array.from({ length: 10 }, (_, index) => ({ name: `p_${String(index).padStart(2, "0")}`, object_type: "PROCEDURE", schema: "app", signature: "" })),
+ { name: "run", object_type: "PROCEDURE", schema: "app", signature: "v integer" },
+ { name: "run", object_type: "PROCEDURE", schema: "app", signature: "v text" },
+ ];
+ const listObjects = vi.fn((_connectionId: string, _database: string, _schema: string, _objectTypes: string[], _filter?: string, limit?: number, offset = 0) => Promise.resolve(objects.slice(offset, offset + (limit ?? objects.length))));
+ vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+ vi.doMock("@/lib/backend/api", () => ({
+ checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+ deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+ listObjects,
+ loadSchemaCache: vi.fn().mockResolvedValue(null),
+ saveSchemaCache: vi.fn().mockResolvedValue(undefined),
+ saveConnections: vi.fn().mockResolvedValue(undefined),
+ saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+ }));
+ const { useConnectionStore } = await import("@/stores/connectionStore");
+ const { useSettingsStore } = await import("@/stores/settingsStore");
+ const store = useConnectionStore();
+ const settings = useSettingsStore();
+ settings.editorSettings.sidebarObjectDisplay = "grouped";
+ settings.desktopSettings.sidebar_table_page_size = 11;
+ const connection = { ...postgresConnection(), id: "kingbase-1", name: "Kingbase", db_type: "kingbase" as const, database: "onepass" };
+ const group: TreeNode = { id: "kingbase-1:onepass:app:__procedures", label: "tree.procedures", type: "group-procedures", connectionId: connection.id, database: "onepass", schema: "app", children: [] };
+ store.connections = [connection];
+ store.connectedIds.add(connection.id);
+ store.treeNodes = [{ id: connection.id, label: connection.name, type: "connection", connectionId: connection.id, children: [{ id: "kingbase-1:onepass:app", label: "app", type: "schema", connectionId: connection.id, database: "onepass", schema: "app", children: [group] }] }];
+
+ await store.loadObjectGroupChildren(group);
+ expect(listObjects).toHaveBeenNthCalledWith(1, connection.id, "onepass", "app", ["PROCEDURE"], undefined, 12, 0);
+ expect(group.children?.filter((node) => node.type === "procedure")).toHaveLength(11);
+ const more = group.children?.at(-1);
+ expect(more?.type).toBe("load-more");
+ await store.loadMoreObjectGroupChildren(more!);
+
+ expect(listObjects).toHaveBeenNthCalledWith(2, connection.id, "onepass", "app", ["PROCEDURE"], undefined, 12, 11);
+ const procedures = group.children?.filter((node) => node.type === "procedure") ?? [];
+ expect(procedures).toHaveLength(12);
+ expect(new Set(procedures.map((node) => node.id)).size).toBe(12);
+ expect(procedures.filter((node) => node.objectName === "run").map((node) => node.signature)).toEqual(["v integer", "v text"]);
+ expect(procedures.filter((node) => node.objectName !== "run").map((node) => node.signature)).toEqual(Array(10).fill(""));
+ expect(group.children?.some((node) => node.type === "load-more")).toBe(false);
+ }, 20000);
+
it("merges Xugu package body metadata when it arrives on the next page", async () => {
const packageSpec: ObjectInfo = {
name: "business_api",
diff --git a/crates/dbx-core/src/schema/mod.rs b/crates/dbx-core/src/schema/mod.rs
index c3dc4b368a..d888c06e4d 100644
--- a/crates/dbx-core/src/schema/mod.rs
+++ b/crates/dbx-core/src/schema/mod.rs
@@ -11434,6 +11434,7 @@ async fn managed_object_source<T: serde::de::DeserializeOwned + Send + 'static>(
schema: &str,
name: &str,
object_type: &db::ObjectSourceKind,
+ signature: Option<&str>,
relation_name: Option<&str>,
timeout: Option<Duration>,
) -> Result<T, String> {
@@ -11442,23 +11443,22 @@ async fn managed_object_source<T: serde::de::DeserializeOwned + Send + 'static>(
client
.lock()
.await
- .get_object_source_for_relation(database, schema, name, object_type, relation_name, timeout)
+ .get_object_source_with_identity(database, schema, name, object_type, signature, relation_name, timeout)
.await
}
PoolKind::ExternalDriver { config, session, .. } => {
- session
- .invoke_with_timeout(
- "getObjectSource",
- serde_json::json!({
- "connection": config.as_ref(),
- "database": database,
- "schema": schema,
- "name": name,
- "object_type": object_type,
- }),
- timeout,
- )
- .await
+ let mut params = serde_json::json!({
+ "connection": config.as_ref(),
+ "database": database,
+ "schema": schema,
+ "name": name,
+ "object_type": object_type,
+ });
+ // An empty signature identifies the zero-argument overload; absence means unknown.
+ if let Some(signature) = signature {
+ params["signature"] = serde_json::Value::String(signature.to_string());
+ }
+ session.invoke_with_timeout("getObjectSource", params, timeout).await
}
_ => Err("Managed object source is not supported for this connection".into()),
}
@@ -11511,6 +11511,7 @@ async fn get_object_source_once(
schema,
name,
&object_type,
+ signature,
None,
agent_metadata_timeout(Some(config.as_ref())),
)
@@ -11570,6 +11571,7 @@ async fn get_object_source_once(
schema,
name,
&object_type,
+ signature,
relation_name,
agent_metadata_timeout(db_config.as_ref()),
)
diff --git a/crates/dbx-core/src/schema/oracle_routines.rs b/crates/dbx-core/src/schema/oracle_routines.rs
index 0f905683c1..01200695d1 100644
--- a/crates/dbx-core/src/schema/oracle_routines.rs
+++ b/crates/dbx-core/src/schema/oracle_routines.rs
@@ -255,6 +255,7 @@ impl RoutineCatalog for LiveCatalog<'_> {
&identity.name,
&identity.kind,
None,
+ None,
agent_metadata_timeout(Some(self.config)),
)
.await
diff --git a/crates/dbx-driver-agent/src/agent_driver.rs b/crates/dbx-driver-agent/src/agent_driver.rs
index 43f1511c46..e67192ede0 100644
--- a/crates/dbx-driver-agent/src/agent_driver.rs
+++ b/crates/dbx-driver-agent/src/agent_driver.rs
@@ -2382,10 +2382,24 @@ impl AgentDriverClient {
object_type: &K,
relation_name: Option<&str>,
timeout_duration: Option<Duration>,
+ ) -> Result<T, String> {
+ self.get_object_source_with_identity(database, schema, name, object_type, None, relation_name, timeout_duration)
+ .await
+ }
+
+ pub async fn get_object_source_with_identity<T: DeserializeOwned + Send + 'static, K: Serialize>(
+ &mut self,
+ database: &str,
+ schema: &str,
+ name: &str,
+ object_type: &K,
+ signature: Option<&str>,
+ relation_name: Option<&str>,
+ timeout_duration: Option<Duration>,
) -> Result<T, String> {
self.call_method_with_timeout(
AgentMethod::GetObjectSource,
- agent_object_source_params_with_relation(database, schema, name, object_type, relation_name),
+ agent_object_source_params_with_identity(database, schema, name, object_type, signature, relation_name),
timeout_duration,
)
.await
@@ -3330,9 +3344,24 @@ pub fn agent_object_source_params_with_relation<K: Serialize>(
name: &str,
object_type: &K,
relation_name: Option<&str>,
+) -> Value {
+ agent_object_source_params_with_identity(database, schema, name, object_type, None, relation_name)
+}
+
+pub fn agent_object_source_params_with_identity<K: Serialize>(
+ database: &str,
+ schema: &str,
+ name: &str,
+ object_type: &K,
+ signature: Option<&str>,
+ relation_name: Option<&str>,
) -> Value {
let mut params =
serde_json::json!({ "database": database, "schema": schema, "name": name, "object_type": object_type });
+ // An empty signature identifies the zero-argument overload; absence means unknown.
+ if let Some(signature) = signature {
+ params["signature"] = Value::String(signature.to_string());
+ }
if let Some(relation_name) = relation_name.map(str::trim).filter(|value| !value.is_empty()) {
params["relation_name"] = Value::String(relation_name.to_string());
}
@@ -3830,17 +3859,18 @@ mod tests {
use super::{
agent_close_query_session_params, agent_error_from_legacy, agent_handshake_params, agent_java_args,
agent_java_args_with_extra, agent_java_args_with_extra_opts, agent_object_source_params,
- agent_object_source_params_with_relation, agent_process_error_hint, agent_proxy_env_vars, agent_schema_params,
- agent_schema_table_params, agent_supports_capability, agent_transaction_params, append_legacy_error_context,
- decode_agent_response, format_agent_process_error, format_agent_startup_error, is_agent_rpc_response_error,
- is_retryable_agent_startup_error, is_unsupported_handshake_error, legacy_agent_call_error,
- mongo_collection_params, mongo_database_params, mongo_document_id_params, parse_agent_java_opts,
- read_agent_json_response, read_agent_line, read_agent_line_with_limit, start_stderr_collector,
- validate_dameng_java_system_properties, AgentCallError, AgentCapability, AgentDriverClient, AgentErrorCategory,
- AgentErrorContext, AgentErrorStage, AgentHandshake, AgentKvMethod, AgentLaunchSpec, AgentMethod,
- AgentOperationOutcome, AgentRuntimeClient, AgentSessionDisposition, AgentTableReadCloseParams,
- AgentTableReadPageParams, AgentTableReadStartParams, MongoAgentMethod, StderrTail, AGENT_JAVA_TOO_OLD_MESSAGE,
- AGENT_PROTOCOL_VERSION, AGENT_STDOUT_NOISE_SAMPLE_CHARS, MAX_CONSECUTIVE_AGENT_STDOUT_NOISE_LINES,
+ agent_object_source_params_with_identity, agent_object_source_params_with_relation, agent_process_error_hint,
+ agent_proxy_env_vars, agent_schema_params, agent_schema_table_params, agent_supports_capability,
+ agent_transaction_params, append_legacy_error_context, decode_agent_response, format_agent_process_error,
+ format_agent_startup_error, is_agent_rpc_response_error, is_retryable_agent_startup_error,
+ is_unsupported_handshake_error, legacy_agent_call_error, mongo_collection_params, mongo_database_params,
+ mongo_document_id_params, parse_agent_java_opts, read_agent_json_response, read_agent_line,
+ read_agent_line_with_limit, start_stderr_collector, validate_dameng_java_system_properties, AgentCallError,
+ AgentCapability, AgentDriverClient, AgentErrorCategory, AgentErrorContext, AgentErrorStage, AgentHandshake,
+ AgentKvMethod, AgentLaunchSpec, AgentMethod, AgentOperationOutcome, AgentRuntimeClient,
+ AgentSessionDisposition, AgentTableReadCloseParams, AgentTableReadPageParams, AgentTableReadStartParams,
+ MongoAgentMethod, StderrTail, AGENT_JAVA_TOO_OLD_MESSAGE, AGENT_PROTOCOL_VERSION,
+ AGENT_STDOUT_NOISE_SAMPLE_CHARS, MAX_CONSECUTIVE_AGENT_STDOUT_NOISE_LINES,
};
use crate::agent_recovery::{RecoveryDecision, RecoveryPolicy, RecoveryScope};
use std::io::Cursor;
@@ -6242,6 +6272,25 @@ for line in sys.stdin:
);
}
+ #[test]
+ fn object_source_params_preserve_overload_identity() {
+ for signature in ["", "v integer", "v INOUT integer"] {
+ assert_eq!(
+ agent_object_source_params_with_identity("onepass", "app", "run", &"PROCEDURE", Some(signature), None),
+ serde_json::json!({
+ "database": "onepass", "schema": "app", "name": "run",
+ "object_type": "PROCEDURE", "signature": signature,
+ })
+ );
+ }
+ let params = agent_object_source_params_with_identity("onepass", "app", "run", &"PROCEDURE", None, None);
+ assert!(params.get("signature").is_none());
+ let params =
+ agent_object_source_params_with_identity("onepass", "app", "audit", &"TRIGGER", None, Some("orders"));
+ assert_eq!(params["relation_name"], "orders");
+ assert!(params.get("signature").is_none());
+ }
+
#[test]
fn agent_protocol_matches_contract_file() {
let contract: serde_json::Value =
diff --git a/crates/dbx-sql-schema/src/db_admin_sql.rs b/crates/dbx-sql-schema/src/db_admin_sql.rs
index a1a8be9676..1765a8566b 100644
--- a/crates/dbx-sql-schema/src/db_admin_sql.rs
+++ b/crates/dbx-sql-schema/src/db_admin_sql.rs
@@ -449,7 +449,7 @@ pub fn build_create_user_sql(username: &str, password: &str, tablespace: &str) -
}
pub fn build_drop_object_sql(options: DropObjectSqlOptions) -> String {
- let signature = if matches!(options.database_type, Some(DatabaseType::Postgres))
+ let signature = if matches!(options.database_type, Some(DatabaseType::Postgres | DatabaseType::Kingbase))
&& matches!(options.object_type, DatabaseObjectType::Function | DatabaseObjectType::Procedure)
{
options.signature.as_deref().map(|value| format!("({value})")).unwrap_or_default()
@@ -2241,6 +2241,27 @@ mod tests {
}
}
+ #[test]
+ fn kingbase_drop_object_sql_preserves_routine_signature() {
+ for (object_type, keyword) in
+ [(DatabaseObjectType::Procedure, "PROCEDURE"), (DatabaseObjectType::Function, "FUNCTION")]
+ {
+ for signature in ["", "v integer", "v INOUT integer"] {
+ assert_eq!(
+ build_drop_object_sql(DropObjectSqlOptions {
+ database_type: Some(DatabaseType::Kingbase),
+ object_type,
+ schema: Some("app".to_string()),
+ name: "run".to_string(),
+ signature: Some(signature.to_string()),
+ identifier_quote: None,
+ }),
+ format!("DROP {keyword} \"app\".\"run\"({signature});")
+ );
+ }
+ }
+ }
+
#[test]
fn builds_drop_object_database_and_schema_sql() {
assert_eq!(