From 4c38b389ce2655533072ede4466014819090a08e Mon Sep 17 00:00:00 2001 From: t8y2 <1156263951@qq.com> Date: Wed, 19 Aug 2026 11:24:56 +0000 Subject: [PATCH] fix(kingbase): list schema triggers with parent tables Closes #6707 --- .../drivers/kingbase-go/kingbase_metadata.go | 106 +++++++++++++- agents/drivers/kingbase-go/main.go | 2 +- agents/drivers/kingbase-go/main_test.go | 133 ++++++++++++++++++ .../databaseObjectCapabilities.spec.ts | 6 + .../src/lib/__tests__/table/tableTree.spec.ts | 22 +++ .../database/databaseObjectCapabilities.ts | 13 +- apps/desktop/src/lib/table/tableTree.ts | 23 ++- crates/dbx-core/src/db/agent_driver.rs | 61 ++++++-- crates/dbx-core/src/schema.rs | 9 +- 9 files changed, 345 insertions(+), 30 deletions(-) diff --git a/agents/drivers/kingbase-go/kingbase_metadata.go b/agents/drivers/kingbase-go/kingbase_metadata.go index ef18bb8e57..c549e9aaf0 100644 --- a/agents/drivers/kingbase-go/kingbase_metadata.go +++ b/agents/drivers/kingbase-go/kingbase_metadata.go @@ -70,6 +70,8 @@ type objectInfo struct { Name string `json:"name"` ObjectType string `json:"object_type"` Schema string `json:"schema"` + ParentSchema *string `json:"parent_schema,omitempty"` + ParentName *string `json:"parent_name,omitempty"` Comment *string `json:"comment"` Valid *bool `json:"valid,omitempty"` CustomTypeKind *string `json:"custom_type_kind,omitempty"` @@ -1123,6 +1125,13 @@ WHERE n.nspname = %s ORDER BY p.proname`, catalog, function, catalog, function, _ = rows.Close() } } + if constraintsAllowTriggers(constraints) { + triggers, triggerErr := s.listTriggerObjects(effective) + if triggerErr != nil { + return nil, fmt.Errorf("list triggers in schema %q: %w", effective, triggerErr) + } + result = append(result, triggers...) + } if constraintsAllowTypes(constraints) { types, typesErr := s.listCustomTypes(effective) if typesErr != nil { @@ -1148,6 +1157,50 @@ WHERE n.nspname = %s ORDER BY p.proname`, catalog, function, catalog, function, return pageObjects(filtered, constraints), nil } +func (s *server) listTriggerObjects(schema string) ([]objectInfo, error) { + effective, err := s.effectiveSchema(schema) + if err != nil { + return nil, err + } + catalog, prefix := "sys_catalog", "sys" + if s.mode.postgresCatalog { + catalog, prefix = "pg_catalog", "pg" + } + queryForCatalog := func() string { + internalPredicate := "NOT tg.tgisinternal" + if s.triggerInternalUnsupported { + internalPredicate = "tg.tgkind <> 'c'" + } + return fmt.Sprintf(`SELECT tg.tgname, c.relname, d.description +FROM %s.%s_trigger tg JOIN %s.%s_class c ON c.oid = tg.tgrelid +JOIN %s.%s_namespace n ON n.oid = c.relnamespace +LEFT JOIN %s.%s_description d ON d.objoid = tg.oid AND d.objsubid = 0 +WHERE n.nspname = %s AND %s ORDER BY c.relname, tg.tgname`, catalog, prefix, catalog, prefix, catalog, prefix, catalog, prefix, quoteLiteral(effective), internalPredicate) + } + rows, err := s.metadataQuery(queryForCatalog()) + if err != nil && !s.triggerInternalUnsupported && isUndefinedColumn(err, "tgisinternal") { + s.triggerInternalUnsupported = true + rows, err = s.metadataQuery(queryForCatalog()) + } + if err != nil { + return nil, err + } + defer rows.Close() + result := []objectInfo{} + for rows.Next() { + var name, parentName string + var comment sql.NullString + if err := rows.Scan(&name, &parentName, &comment); err != nil { + return nil, err + } + result = append(result, objectInfo{ + Name: name, ObjectType: "TRIGGER", Schema: effective, + ParentSchema: stringPtr(effective), ParentName: stringPtr(parentName), Comment: nullStringPtr(comment), + }) + } + return result, rows.Err() +} + func (s *server) completionAssistantSearch(request completionAssistantRequest) (completionAssistantResponse, error) { limit := request.MaxResults if limit <= 0 || limit > 1000 { @@ -1728,6 +1781,10 @@ WHERE n.nspname = %s AND c.relname = %s AND %s ORDER BY tg.tgname`, catalog, pre } func (s *server) getObjectSource(schema, name, objectType string) (map[string]any, error) { + return s.getObjectSourceForRelation(schema, name, objectType, "") +} + +func (s *server) getObjectSourceForRelation(schema, name, objectType, relationName string) (map[string]any, error) { effective, err := s.effectiveSchema(schema) if err != nil { return nil, err @@ -1787,11 +1844,26 @@ func (s *server) getObjectSource(schema, name, objectType string) (map[string]an err = queryLegacySource() } } + } else if kind == "TRIGGER" { + definitions, triggerErr := s.listTriggerDefinitionsFor(effective, relationName, name) + if triggerErr != nil { + err = triggerErr + } else if len(definitions) == 1 { + source = definitions[0] + } else if len(definitions) > 1 { + err = fmt.Errorf("trigger %q is ambiguous in schema %q; relation_name is required", name, effective) + } else { + err = sql.ErrNoRows + } } if err != nil && err != sql.ErrNoRows { return nil, err } - return map[string]any{"name": name, "object_type": objectType, "schema": effective, "source": source}, nil + result := map[string]any{"name": name, "object_type": objectType, "schema": effective, "source": source} + if kind == "TRIGGER" { + result["editable"] = false + } + return result, nil } func (s *server) getTableDDL(schema, table string) (string, error) { @@ -1896,6 +1968,10 @@ WHERE n.nspname = %s AND t.relname = %s AND NOT ix.indisprimary ORDER BY i.relna } func (s *server) listTriggerDefinitions(schema, table string) ([]string, error) { + return s.listTriggerDefinitionsFor(schema, table, "") +} + +func (s *server) listTriggerDefinitionsFor(schema, table, trigger string) ([]string, error) { effective, err := s.effectiveSchema(schema) if err != nil { return nil, err @@ -1914,9 +1990,17 @@ func (s *server) listTriggerDefinitions(schema, table string) ([]string, error) if s.triggerInternalUnsupported { internalPredicate = "tg.tgkind <> 'c'" } + relationFilter := "" + if strings.TrimSpace(table) != "" { + relationFilter = " AND c.relname = " + quoteLiteral(table) + } + triggerFilter := "" + if strings.TrimSpace(trigger) != "" { + triggerFilter = " AND tg.tgname = " + quoteLiteral(trigger) + } return fmt.Sprintf(`SELECT %s(%s) FROM %s.%s_trigger tg JOIN %s.%s_class c ON c.oid = tg.tgrelid JOIN %s.%s_namespace n ON n.oid = c.relnamespace -WHERE n.nspname = %s AND c.relname = %s AND %s ORDER BY tg.tgname`, triggerDefinitionFunction, arguments, catalog, prefix, catalog, prefix, catalog, prefix, quoteLiteral(effective), quoteLiteral(table), internalPredicate) +WHERE n.nspname = %s%s%s AND %s ORDER BY c.relname, tg.tgname`, triggerDefinitionFunction, arguments, catalog, prefix, catalog, prefix, catalog, prefix, quoteLiteral(effective), relationFilter, triggerFilter, internalPredicate) } var rows *sql.Rows for { @@ -2149,7 +2233,7 @@ func normalizeTableType(value string) string { switch normalized { case "BASE_TABLE", "PARTITIONED_TABLE": return "TABLE" - case "MATERIALIZED_VIEW", "FOREIGN_TABLE", "VIEW", "TABLE", "TYPE", "TYPE_BODY": + case "MATERIALIZED_VIEW", "FOREIGN_TABLE", "VIEW", "TABLE", "TRIGGER", "TYPE", "TYPE_BODY": return normalized default: return "TABLE" @@ -2227,6 +2311,18 @@ func constraintsAllowRoutines(constraints metadataListConstraints) bool { return false } +// Schema triggers are opt-in because legacy unfiltered object calls predate +// this object family. Sidebar requests include explicit object types, while +// completion callers keep their existing bounded result set. +func constraintsAllowTriggers(constraints metadataListConstraints) bool { + for _, kind := range constraints.ObjectTypes { + if normalizeTableType(kind) == "TRIGGER" { + return true + } + } + return false +} + func routineObjectType(value string) string { upper := strings.ToUpper(strings.TrimSpace(value)) switch { @@ -2303,8 +2399,10 @@ func objectOrder(kind string) int { return 4 case "FUNCTION": return 5 - case "TYPE": + case "TRIGGER": return 6 + case "TYPE": + return 7 default: return 9 } diff --git a/agents/drivers/kingbase-go/main.go b/agents/drivers/kingbase-go/main.go index b4fcf1c3ee..2a198293dc 100644 --- a/agents/drivers/kingbase-go/main.go +++ b/agents/drivers/kingbase-go/main.go @@ -411,7 +411,7 @@ 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.getObjectSource(stringParam(params, "schema"), stringParam(params, "name"), stringParam(params, "object_type")) + result, err := s.getObjectSourceForRelation(stringParam(params, "schema"), stringParam(params, "name"), stringParam(params, "object_type"), stringParam(params, "relation_name")) return result, false, err case "get_type_details": result, err := s.getTypeDetails(stringParam(params, "schema"), stringParam(params, "name")) diff --git a/agents/drivers/kingbase-go/main_test.go b/agents/drivers/kingbase-go/main_test.go index 9ae76e527d..e378e318b4 100644 --- a/agents/drivers/kingbase-go/main_test.go +++ b/agents/drivers/kingbase-go/main_test.go @@ -1801,6 +1801,86 @@ func TestListObjectsUsesCatalogRoutinesOutsideMySQLCompat(t *testing.T) { } } +func TestListObjectsOnlyTriggersWithParentIdentity(t *testing.T) { + for _, test := range []struct { + name string + mode kingbaseMode + catalog string + prefix string + }{ + {name: "sys catalog", catalog: "sys_catalog", prefix: "sys"}, + {name: "pg catalog", mode: kingbaseMode{postgresCatalog: true}, catalog: "pg_catalog", prefix: "pg"}, + } { + t.Run(test.name, func(t *testing.T) { + state := &metadataDriverState{query: func(query string) (driver.Rows, error) { + triggerTable := test.catalog + "." + test.prefix + "_trigger" + if !strings.Contains(query, "FROM "+triggerTable+" tg") || !strings.Contains(query, "NOT tg.tgisinternal") { + return nil, errors.New("trigger-only request issued an unexpected query: " + query) + } + if !strings.Contains(query, test.catalog+"."+test.prefix+"_description") || !strings.Contains(query, "n.nspname = 'team''s'") { + return nil, errors.New("trigger query lost comment or quoted schema metadata: " + query) + } + return &valueRows{ + columns: []string{"tgname", "relname", "description"}, + rows: [][]driver.Value{ + {"audit_before", "items", "items audit"}, + {"audit_before", "orders", nil}, + }, + }, nil + }} + server := newServer() + server.db = openMetadataDB(t, state) + server.mode = test.mode + + objects, err := server.listObjects("team's", metadataListConstraints{ObjectTypes: []string{"TRIGGER"}}) + if err != nil { + t.Fatal(err) + } + if len(objects) != 2 { + t.Fatalf("expected both table-scoped triggers, got %#v", objects) + } + for index, parent := range []string{"items", "orders"} { + object := objects[index] + if object.Name != "audit_before" || object.ObjectType != "TRIGGER" || object.Schema != "team's" || object.ParentSchema == nil || *object.ParentSchema != "team's" || object.ParentName == nil || *object.ParentName != parent { + t.Fatalf("unexpected trigger object at %d: %#v", index, object) + } + } + if queries := state.snapshotQueries(); len(queries) != 1 { + t.Fatalf("trigger-only request must use one bounded catalog query: %v", queries) + } + constraints := metadataListConstraints{ObjectTypes: []string{"TRIGGER"}} + if constraintsAllowsTableLike(constraints) || constraintsAllowRoutines(constraints) || constraintsAllowTypes(constraints) || !constraintsAllowTriggers(constraints) { + t.Fatalf("trigger-only constraint leaked into another object family: %#v", constraints) + } + }) + } +} + +func TestListObjectsTriggerFallbackExcludesConstraintTriggers(t *testing.T) { + state := &metadataDriverState{query: func(query string) (driver.Rows, error) { + if strings.Contains(query, "tg.tgisinternal") { + return nil, &gokb.Error{Code: gokb.ErrorCode("42703"), Message: "column TG.TGISINTERNAL does not exist"} + } + if !strings.Contains(query, "tg.tgkind <> 'c'") { + return nil, errors.New("legacy trigger query did not exclude constraint triggers: " + query) + } + return &valueRows{ + columns: []string{"tgname", "relname", "description"}, + rows: [][]driver.Value{{"audit_before", "orders", nil}}, + }, nil + }} + server := newServer() + server.db = openMetadataDB(t, state) + + objects, err := server.listObjects("public", metadataListConstraints{ObjectTypes: []string{"TRIGGER"}}) + if err != nil { + t.Fatal(err) + } + if len(objects) != 1 || objects[0].ParentName == nil || *objects[0].ParentName != "orders" || !server.triggerInternalUnsupported { + t.Fatalf("unexpected legacy trigger objects: %#v", objects) + } +} + func TestListObjectsKeepsTablesWhenMySQLCompatRoutineQueryFails(t *testing.T) { state := &metadataDriverState{query: func(query string) (driver.Rows, error) { switch { @@ -2207,6 +2287,59 @@ func TestRoutineSourceUsesKingbaseCatalogFunction(t *testing.T) { } } +func TestTriggerObjectSourceUsesOwningRelation(t *testing.T) { + state := &metadataDriverState{query: func(query string) (driver.Rows, error) { + for _, fragment := range []string{ + "SELECT sys_catalog.sys_get_triggerdef(tg.oid, true)", + "FROM sys_catalog.sys_trigger tg", + "n.nspname = 'public'", + "c.relname = 'orders'", + "tg.tgname = 'audit_before'", + "NOT tg.tgisinternal", + } { + if !strings.Contains(query, fragment) { + return nil, errors.New("trigger source query missing " + fragment + ": " + query) + } + } + return &valueRows{columns: []string{"definition"}, rows: [][]driver.Value{{"CREATE TRIGGER audit_before BEFORE INSERT ON public.orders EXECUTE FUNCTION public.audit_row()"}}}, nil + }} + server := newServer() + server.db = openMetadataDB(t, state) + + source, err := server.getObjectSourceForRelation("public", "audit_before", "TRIGGER", "orders") + if err != nil { + t.Fatal(err) + } + if !strings.Contains(fmt.Sprint(source["source"]), "ON public.orders") { + t.Fatalf("unexpected trigger source: %#v", source) + } + if source["editable"] != false { + t.Fatalf("trigger source must remain read-only: %#v", source) + } +} + +func TestTriggerObjectSourceRejectsAmbiguousNameWithoutRelation(t *testing.T) { + state := &metadataDriverState{query: func(query string) (driver.Rows, error) { + if strings.Contains(query, "AND c.relname =") || !strings.Contains(query, "tg.tgname = 'audit_before'") { + return nil, errors.New("unexpected unscoped trigger source query: " + query) + } + return &valueRows{ + columns: []string{"definition"}, + rows: [][]driver.Value{ + {"CREATE TRIGGER audit_before BEFORE INSERT ON public.items EXECUTE FUNCTION public.audit_row()"}, + {"CREATE TRIGGER audit_before BEFORE INSERT ON public.orders EXECUTE FUNCTION public.audit_row()"}, + }, + }, nil + }} + server := newServer() + server.db = openMetadataDB(t, state) + + _, err := server.getObjectSource("public", "audit_before", "TRIGGER") + if err == nil || !strings.Contains(err.Error(), "relation_name is required") { + t.Fatalf("ambiguous trigger name must require its owning relation: %v", err) + } +} + func TestObjectSourceFallsBackToPgDefinitionFunctionsAndCachesChoice(t *testing.T) { tests := []struct { name string diff --git a/apps/desktop/src/lib/__tests__/database/databaseObjectCapabilities.spec.ts b/apps/desktop/src/lib/__tests__/database/databaseObjectCapabilities.spec.ts index 2d55f1a6ae..b11f3bc5d1 100644 --- a/apps/desktop/src/lib/__tests__/database/databaseObjectCapabilities.spec.ts +++ b/apps/desktop/src/lib/__tests__/database/databaseObjectCapabilities.spec.ts @@ -62,6 +62,12 @@ describe("databaseObjectCapabilities", () => { } }); + it("exposes schema triggers for Kingbase without widening Vastbase", () => { + expect(sidebarObjectKindsForDatabase("kingbase")).toContain("TRIGGER"); + expect(databaseObjectCapabilities("kingbase").sourceReadable).toContain("TRIGGER"); + expect(sidebarObjectKindsForDatabase("vastbase")).not.toContain("TRIGGER"); + }); + it("only Xugu TYPE nodes can open object source", () => { expect(supportsTypeObjectSource("xugu")).toBe(true); for (const dbType of ["postgres", "opengauss", "gaussdb", "kingbase", "vastbase", undefined] as const) { diff --git a/apps/desktop/src/lib/__tests__/table/tableTree.spec.ts b/apps/desktop/src/lib/__tests__/table/tableTree.spec.ts index 5fb5a6c4df..d2a499abee 100644 --- a/apps/desktop/src/lib/__tests__/table/tableTree.spec.ts +++ b/apps/desktop/src/lib/__tests__/table/tableTree.spec.ts @@ -248,6 +248,28 @@ describe("programmable database objects", () => { ]); }); + it("keeps table-scoped Kingbase triggers distinct and source-addressable", () => { + const objects: ObjectInfo[] = [ + { name: "audit_before", object_type: "TRIGGER", schema: "public", parent_schema: "public", parent_name: "items" }, + { name: "audit_before", object_type: "TRIGGER", schema: "public", parent_schema: "public", parent_name: "orders" }, + ]; + + const simple = buildSimpleObjectTreeNodes({ ...context, schema: "public", objects, databaseType: "kingbase" }); + expect(simple.map((node) => ({ label: node.label, tableName: node.tableName }))).toEqual([ + { label: "audit_before (items)", tableName: "items" }, + { label: "audit_before (orders)", tableName: "orders" }, + ]); + expect(new Set(simple.map((node) => node.id)).size).toBe(2); + + const grouped = buildGroupedObjectTreeNodes({ ...context, schema: "public", objects, databaseType: "kingbase" }); + const triggers = grouped.find((node) => node.type === "group-triggers")?.children ?? []; + expect(triggers.map((node) => ({ label: node.label, objectName: node.objectName, tableName: node.tableName }))).toEqual([ + { label: "audit_before (items)", objectName: "audit_before", tableName: "items" }, + { label: "audit_before (orders)", objectName: "audit_before", tableName: "orders" }, + ]); + expect(new Set(triggers.map((node) => node.id)).size).toBe(2); + }); + it("groups Xugu private synonyms as source objects", () => { const objects: ObjectInfo[] = [{ name: "SYN_SHOP_USERS", object_type: "SYNONYM", schema: "SYSDBA", valid: true }]; diff --git a/apps/desktop/src/lib/database/databaseObjectCapabilities.ts b/apps/desktop/src/lib/database/databaseObjectCapabilities.ts index 983bd6ae8b..f0bc8e4690 100644 --- a/apps/desktop/src/lib/database/databaseObjectCapabilities.ts +++ b/apps/desktop/src/lib/database/databaseObjectCapabilities.ts @@ -24,10 +24,11 @@ const POSTGRES_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VI const POSTGRES_NO_TYPE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE"]; // Kingbase and Vastbase agents support the same user-defined type listing via -// their own metadata query, but do not expose sequences. Kept separate from -// POSTGRES_OBJECTS and POSTGRES_LIKE_OBJECTS so unverified PG-like databases -// (highgo/uxdb/redshift) never advertise TYPE. -const KINGBASE_VASTBASE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "TYPE"]; +// their own metadata query, but do not expose sequences. Kingbase additionally +// has a verified schema-trigger path; keep Vastbase separate until its Agent +// exposes the same parent-table-aware metadata contract. +const KINGBASE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "TRIGGER", "TYPE"]; +const VASTBASE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "TYPE"]; const POSTGRES_LIKE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION"]; const ORACLE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SYNONYM", "PACKAGE", "PACKAGE_BODY"]; @@ -43,10 +44,10 @@ const DATABASE_TYPE_OBJECTS = new Map([ ["kwdb", POSTGRES_NO_TYPE_OBJECTS], ["opengauss", POSTGRES_OBJECTS], // postgres like - ["kingbase", KINGBASE_VASTBASE_OBJECTS], + ["kingbase", KINGBASE_OBJECTS], ["highgo", POSTGRES_LIKE_OBJECTS], ["uxdb", POSTGRES_LIKE_OBJECTS], - ["vastbase", KINGBASE_VASTBASE_OBJECTS], + ["vastbase", VASTBASE_OBJECTS], ["redshift", POSTGRES_LIKE_OBJECTS], // oracle ["oracle", ORACLE_OBJECTS], diff --git a/apps/desktop/src/lib/table/tableTree.ts b/apps/desktop/src/lib/table/tableTree.ts index e01da20f37..dcd445e0e7 100644 --- a/apps/desktop/src/lib/table/tableTree.ts +++ b/apps/desktop/src/lib/table/tableTree.ts @@ -636,7 +636,9 @@ export function buildSimpleObjectTreeNodes({ nodeId, connectionId, database, sch const childSchema = obj.schema ? normalizeDatabaseObjectName(obj.schema) : schema; const signature = obj.signature?.trim() || ""; - const dedupeKey = exactObjectIdentityKey(objectType, childSchema, name, signature); + const triggerParentName = objectType === "TRIGGER" && obj.parent_name ? normalizeDatabaseObjectName(obj.parent_name) : undefined; + const triggerParentSchema = objectType === "TRIGGER" && obj.parent_schema ? normalizeDatabaseObjectName(obj.parent_schema) : undefined; + const dedupeKey = `${exactObjectIdentityKey(objectType, childSchema, name, signature)}\0${triggerParentName || ""}`; if (seen.has(dedupeKey)) continue; seen.add(dedupeKey); @@ -657,8 +659,8 @@ export function buildSimpleObjectTreeNodes({ nodeId, connectionId, database, sch } else { const simpleNodeType = simpleObjectNodeType(objectType); objectNodes.push({ - id: objectType === "VIEW" || objectType === "MATERIALIZED_VIEW" ? entry.node.id : `${nodeId}:${childSchema ? `${childSchema}:` : ""}${name}:${signature}:${objectType}`, - label: signature && (objectType === "FUNCTION" || objectType === "PROCEDURE") ? `${name}(${signature})` : name, + id: objectType === "VIEW" || objectType === "MATERIALIZED_VIEW" ? entry.node.id : `${nodeId}:${childSchema ? `${childSchema}:` : ""}${name}:${signature}:${triggerParentName || ""}:${objectType}`, + label: signature && (objectType === "FUNCTION" || objectType === "PROCEDURE") ? `${name}(${signature})` : triggerParentName ? `${name} (${triggerParentName})` : name, type: simpleNodeType, objectName: name, signature: signature || undefined, @@ -673,6 +675,9 @@ export function buildSimpleObjectTreeNodes({ nodeId, connectionId, database, sch connectionId, database, schema: childSchema, + parentSchema: triggerParentSchema, + parentName: triggerParentName, + tableName: triggerParentName, isExpanded: false, children: undefined, }); @@ -826,7 +831,8 @@ export function buildGroupedObjectTreeNodes({ nodeId, connectionId, database, sc const t = normalizeObjectType(obj.object_type); const objectSchema = obj.schema ? normalizeDatabaseObjectName(obj.schema) : schema || ""; const signature = (obj.signature ?? "").trim(); - const key = exactObjectIdentityKey(t, objectSchema, name, signature); + const triggerParentName = t === "TRIGGER" && obj.parent_name ? normalizeDatabaseObjectName(obj.parent_name) : ""; + const key = `${exactObjectIdentityKey(t, objectSchema, name, signature)}\0${triggerParentName}`; if (seen.has(key)) continue; seen.add(key); const arr = buckets.get(t) ?? []; @@ -856,9 +862,11 @@ export function buildGroupedObjectTreeNodes({ nodeId, connectionId, database, sc const objectTypeSuffix = objectType === "PACKAGE" || objectType === "PACKAGE_BODY" || objectType === "TYPE" || objectType === "TYPE_BODY" ? `:${objectType}` : ""; const signature = obj.signature?.trim() || ""; const signatureIdPart = signature && (objectType === "FUNCTION" || objectType === "PROCEDURE") ? `:${signature}` : ""; + const triggerParentName = objectType === "TRIGGER" && obj.parent_name ? normalizeDatabaseObjectName(obj.parent_name) : undefined; + const triggerParentSchema = objectType === "TRIGGER" && obj.parent_schema ? normalizeDatabaseObjectName(obj.parent_schema) : undefined; return { - id: `${nodeId}:${def.key}:${childSchema ? `${childSchema}:` : ""}${obj.name}${signatureIdPart}${objectTypeSuffix}`, - label: signature && (objectType === "FUNCTION" || objectType === "PROCEDURE") ? `${obj.name}(${signature})` : obj.name, + id: `${nodeId}:${def.key}:${childSchema ? `${childSchema}:` : ""}${obj.name}${signatureIdPart}${triggerParentName ? `:${triggerParentName}` : ""}${objectTypeSuffix}`, + label: signature && (objectType === "FUNCTION" || objectType === "PROCEDURE") ? `${obj.name}(${signature})` : triggerParentName ? `${obj.name} (${triggerParentName})` : obj.name, type: childType, objectName: obj.name, signature: signature || undefined, @@ -873,6 +881,9 @@ export function buildGroupedObjectTreeNodes({ nodeId, connectionId, database, sc connectionId, database, schema: childSchema, + parentSchema: triggerParentSchema, + parentName: triggerParentName, + tableName: triggerParentName, isExpanded: false, children: undefined, }; diff --git a/crates/dbx-core/src/db/agent_driver.rs b/crates/dbx-core/src/db/agent_driver.rs index 0b501625ea..9f6254c24a 100644 --- a/crates/dbx-core/src/db/agent_driver.rs +++ b/crates/dbx-core/src/db/agent_driver.rs @@ -2050,10 +2050,22 @@ impl AgentDriverClient { name: &str, object_type: &K, timeout_duration: Option, + ) -> Result { + self.get_object_source_for_relation(database, schema, name, object_type, None, timeout_duration).await + } + + pub async fn get_object_source_for_relation( + &mut self, + database: &str, + schema: &str, + name: &str, + object_type: &K, + relation_name: Option<&str>, + timeout_duration: Option, ) -> Result { self.call_method_with_timeout( AgentMethod::GetObjectSource, - agent_object_source_params(database, schema, name, object_type), + agent_object_source_params_with_relation(database, schema, name, object_type, relation_name), timeout_duration, ) .await @@ -2806,7 +2818,22 @@ pub fn agent_schema_table_params(database: &str, schema: &str, table: &str) -> V } pub fn agent_object_source_params(database: &str, schema: &str, name: &str, object_type: &K) -> Value { - serde_json::json!({ "database": database, "schema": schema, "name": name, "object_type": object_type }) + agent_object_source_params_with_relation(database, schema, name, object_type, None) +} + +pub fn agent_object_source_params_with_relation( + database: &str, + schema: &str, + name: &str, + object_type: &K, + relation_name: Option<&str>, +) -> Value { + let mut params = + serde_json::json!({ "database": database, "schema": schema, "name": name, "object_type": object_type }); + if let Some(relation_name) = relation_name.map(str::trim).filter(|value| !value.is_empty()) { + params["relation_name"] = Value::String(relation_name.to_string()); + } + params } pub fn agent_type_details_params(database: &str, schema: &str, name: &str) -> Value { @@ -3204,16 +3231,16 @@ impl Drop for AgentDriverClient { 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_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_unsupported_handshake_error, legacy_agent_call_error, mongo_collection_params, - mongo_database_params, mongo_document_id_params, parse_agent_java_opts, read_agent_line, - 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_PROTOCOL_VERSION, + agent_java_args_with_extra, agent_java_args_with_extra_opts, agent_object_source_params, + agent_object_source_params_with_relation, 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_unsupported_handshake_error, legacy_agent_call_error, mongo_collection_params, mongo_database_params, + mongo_document_id_params, parse_agent_java_opts, read_agent_line, 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_PROTOCOL_VERSION, }; use crate::agent_recovery::{RecoveryDecision, RecoveryPolicy, RecoveryScope}; use std::io::Cursor; @@ -4695,6 +4722,16 @@ for line in sys.stdin: "object_type": "VIEW", }) ); + assert_eq!( + agent_object_source_params_with_relation("sales", "public", "audit_before", &"TRIGGER", Some("orders")), + serde_json::json!({ + "database": "sales", + "schema": "public", + "name": "audit_before", + "object_type": "TRIGGER", + "relation_name": "orders", + }) + ); assert_eq!(agent_close_query_session_params("session-1"), serde_json::json!({ "sessionId": "session-1" })); assert_eq!( agent_transaction_params(Some("sales"), &["BEGIN".to_string(), "COMMIT".to_string()], Some("public")), diff --git a/crates/dbx-core/src/schema.rs b/crates/dbx-core/src/schema.rs index 907e00e9b0..dd2027f6ae 100644 --- a/crates/dbx-core/src/schema.rs +++ b/crates/dbx-core/src/schema.rs @@ -7908,7 +7908,14 @@ async fn get_object_source_once( } else { let mut client = client.lock().await; let result: db::ObjectSource = client - .get_object_source(database, schema, name, &object_type, agent_metadata_timeout(db_config.as_ref())) + .get_object_source_for_relation( + database, + schema, + name, + &object_type, + relation_name, + agent_metadata_timeout(db_config.as_ref()), + ) .await?; return Ok(result); }