25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(kingbase): 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.goindex 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.goindex 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 boolusePgFunctionDefinition booluseLegacyRoutineDefinition bool+ routineKindUnsupported bool+ routineIdentityFallback intcatalogIdentityUnsupported boolcatalogGeneratedUnsupported boolcatalogOIDUnsupported bool@@ -424,7 +426,13 @@ func (s *server) dispatch(method string, params map[string]json.RawMessage) (anyresult, err := s.listTriggers(stringParam(params, "schema"), stringParam(params, "table"))return result, false, errcase "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, errcase "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 = falses.usePgFunctionDefinition = falses.useLegacyRoutineDefinition = false+ s.routineKindUnsupported = false+ s.routineIdentityFallback = 0s.catalogIdentityUnsupported = falses.catalogGeneratedUnsupported = falses.catalogOIDUnsupported = false@@ -691,6 +701,8 @@ func (s *server) disconnect() error {s.usePgViewDefinition = falses.usePgFunctionDefinition = falses.useLegacyRoutineDefinition = false+ s.routineKindUnsupported = false+ s.routineIdentityFallback = 0s.catalogIdentityUnsupported = falses.catalogGeneratedUnsupported = falses.catalogOIDUnsupported = falsediff --git a/agents/drivers/kingbase-go/main_test.go b/agents/drivers/kingbase-go/main_test.goindex 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) {}, nilcase 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, ""}},}, nilcase 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, ""},},}, nildefault:@@ -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, ""},},}, nildefault:@@ -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 *testfor _, 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, routineErrdefault:return nil, errors.New("unexpected query: " + query)}@@ -2991,15 +2992,12 @@ func TestListObjectsKeepsTablesWhenMySQLCompatRoutineQueryFails(t *testing.T) {server.mode.mysqlCompat = trueobjects, 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, ""}},}, nilcase 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)}}}, nilcase 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.vueindex 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?: bobjectType: 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.tsindex 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: { rendervi.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.vueindex 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.tsindex 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.tsindex 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.tsindex 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, schlabel: 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, sclabel: 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.tsindex 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.rsindex 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.rsindex 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)),).awaitdiff --git a/crates/dbx-driver-agent/src/agent_driver.rs b/crates/dbx-driver-agent/src/agent_driver.rsindex 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.rsindex 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!(