Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

fix(oracle): add trigger operations in structure edit

Loc Nguyene18c60018ce1
diff --git a/agents/drivers/oracle-go/main.go b/agents/drivers/oracle-go/main.go
index d287429a06..a4865e1c9c 100644
--- a/agents/drivers/oracle-go/main.go
+++ b/agents/drivers/oracle-go/main.go
@@ -235,6 +235,9 @@ SELECT t.TRIGGER_NAME,
t.TRIGGERING_EVENT,
t.TRIGGER_TYPE,
t.DESCRIPTION,
+ t.STATUS,
+ t.WHEN_CLAUSE,
+ t.REFERENCING_NAMES,
s.LINE,
s.TEXT
FROM ALL_TRIGGERS t
@@ -523,6 +526,7 @@ type triggerInfo struct {
Event string `json:"event"`
Timing string `json:"timing"`
Statement *string `json:"statement,omitempty"`
+ Enabled *bool `json:"enabled,omitempty"`
}
// constraintInfo represents primary key, unique, and check constraints for a
@@ -2977,28 +2981,38 @@ func (s *server) listTriggers(schema, table string) ([]triggerInfo, error) {
var result []triggerInfo
var currentName string
var currentDescription string
+ var currentStructured bool
var source strings.Builder
flush := func() {
if len(result) == 0 || currentName == "" {
return
}
+ if !currentStructured {
+ // Keep the declaration so callers can tell the source carries clauses the
+ // timing/event/body form cannot round-trip.
+ if body := strings.TrimSpace(strings.ReplaceAll(source.String(), "\r\n", "\n")); body != "" {
+ result[len(result)-1].Statement = &body
+ }
+ return
+ }
if body, ok := oracleTriggerBody(source.String(), currentDescription); ok {
result[len(result)-1].Statement = &body
}
}
for rows.Next() {
var name, event, timing string
- var description, lineText sql.NullString
+ var description, status, whenClause, referencingNames, lineText sql.NullString
var line sql.NullInt64
- if err := rows.Scan(&name, &event, &timing, &description, &line, &lineText); err != nil {
+ if err := rows.Scan(&name, &event, &timing, &description, &status, &whenClause, &referencingNames, &line, &lineText); err != nil {
return nil, err
}
if name != currentName {
flush()
currentName = name
currentDescription = description.String
+ currentStructured = oracleTriggerIsStructured(description.String, whenClause.String, referencingNames.String)
source.Reset()
- result = append(result, triggerInfo{Name: name, Event: event, Timing: timing})
+ result = append(result, triggerInfo{Name: name, Event: event, Timing: timing, Enabled: oracleTriggerEnabled(status)})
}
if line.Valid && lineText.Valid {
source.WriteString(lineText.String)
@@ -3008,6 +3022,33 @@ func (s *server) listTriggers(schema, table string) ([]triggerInfo, error) {
return emptyIfNil(result), rows.Err()
}
+var oracleTriggerUnstructuredClauseRegexp = regexp.MustCompile(`(?i)\b(?:FOLLOWS|PRECEDES|COMPOUND|CROSSEDITION)\b`)
+
+// oracleTriggerIsStructured reports whether a trigger is fully described by its timing, event and
+// PL/SQL body, so it can be rebuilt with CREATE OR REPLACE without dropping a WHEN condition,
+// custom REFERENCING names or FOLLOWS/PRECEDES ordering.
+func oracleTriggerIsStructured(description, whenClause, referencingNames string) bool {
+ if strings.TrimSpace(whenClause) != "" {
+ return false
+ }
+ if referencing := strings.Join(strings.Fields(strings.ToUpper(referencingNames)), " "); referencing != "" && referencing != "REFERENCING NEW AS NEW OLD AS OLD" {
+ return false
+ }
+ return !oracleTriggerUnstructuredClauseRegexp.MatchString(description)
+}
+
+func oracleTriggerEnabled(status sql.NullString) *bool {
+ switch strings.ToUpper(strings.TrimSpace(status.String)) {
+ case "ENABLED":
+ enabled := true
+ return &enabled
+ case "DISABLED":
+ enabled := false
+ return &enabled
+ }
+ return nil
+}
+
func oracleTriggerBody(source, description string) (string, bool) {
source = strings.ReplaceAll(source, "\r\n", "\n")
description = strings.ReplaceAll(description, "\r\n", "\n")
diff --git a/agents/drivers/oracle-go/main_test.go b/agents/drivers/oracle-go/main_test.go
index 49e25321e9..354cb17be8 100644
--- a/agents/drivers/oracle-go/main_test.go
+++ b/agents/drivers/oracle-go/main_test.go
@@ -1109,8 +1109,8 @@ func TestListForeignKeysAndTriggersPreserveQuotedCloneTableName(t *testing.T) {
{
queryContains: "FROM ALL_TRIGGERS",
args: []driver.Value{schema, table},
- columns: []string{"TRIGGER_NAME", "TRIGGERING_EVENT", "TRIGGER_TYPE", "DESCRIPTION", "LINE", "TEXT"},
- rows: [][]driver.Value{{"ORDERS_copy_TRG1", "INSERT", "BEFORE EACH ROW", nil, nil, nil}},
+ columns: []string{"TRIGGER_NAME", "TRIGGERING_EVENT", "TRIGGER_TYPE", "DESCRIPTION", "STATUS", "WHEN_CLAUSE", "REFERENCING_NAMES", "LINE", "TEXT"},
+ rows: [][]driver.Value{{"ORDERS_copy_TRG1", "INSERT", "BEFORE EACH ROW", nil, "DISABLED", nil, nil, nil, nil}},
},
})
s := newServer()
@@ -1130,6 +1130,9 @@ func TestListForeignKeysAndTriggersPreserveQuotedCloneTableName(t *testing.T) {
if len(triggers) != 1 || triggers[0].Name != "ORDERS_copy_TRG1" {
t.Fatalf("listTriggers(%q) = %#v, want quoted clone trigger", table, triggers)
}
+ if triggers[0].Enabled == nil || *triggers[0].Enabled {
+ t.Fatalf("listTriggers(%q) enabled = %v, want disabled from ALL_TRIGGERS.STATUS", table, triggers[0].Enabled)
+ }
if scripted.next != len(scripted.steps) {
t.Fatalf("expected %d queries, got %d", len(scripted.steps), scripted.next)
}
@@ -2216,6 +2219,11 @@ func TestOracleListTriggersSQLLoadsSourceWithoutLongColumns(t *testing.T) {
if !strings.Contains(sqlText, "T.DESCRIPTION") || !strings.Contains(sqlText, "S.TEXT") {
t.Fatalf("trigger listing should load the declaration and source text, got: %s", oracleListTriggersSQL)
}
+ for _, column := range []string{"T.STATUS", "T.WHEN_CLAUSE", "T.REFERENCING_NAMES"} {
+ if !strings.Contains(sqlText, column) {
+ t.Fatalf("trigger listing should load %s, got: %s", column, oracleListTriggersSQL)
+ }
+ }
if strings.Contains(sqlText, "TRIGGER_BODY") {
t.Fatalf("trigger listing should avoid Oracle LONG trigger bodies, got: %s", oracleListTriggersSQL)
}
@@ -2247,6 +2255,69 @@ func TestOracleTriggerBodyStripsDictionaryDeclaration(t *testing.T) {
}
}
+func TestListTriggersKeepsDeclarationForUnstructuredTriggers(t *testing.T) {
+ const schema = "HR"
+ const table = "ORDERS"
+ columns := []string{"TRIGGER_NAME", "TRIGGERING_EVENT", "TRIGGER_TYPE", "DESCRIPTION", "STATUS", "WHEN_CLAUSE", "REFERENCING_NAMES", "LINE", "TEXT"}
+ db, _ := openOracleViewSourceTestDB(t, []oracleViewSourceQueryStep{
+ {
+ queryContains: "FROM ALL_TRIGGERS",
+ args: []driver.Value{schema, table},
+ columns: columns,
+ rows: [][]driver.Value{
+ {"PLAIN_TRG", "INSERT", "BEFORE EACH ROW", "PLAIN_TRG\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\n", "ENABLED", nil, "REFERENCING NEW AS NEW OLD AS OLD", int64(1), "TRIGGER PLAIN_TRG\n"},
+ {"PLAIN_TRG", "INSERT", "BEFORE EACH ROW", "PLAIN_TRG\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\n", "ENABLED", nil, "REFERENCING NEW AS NEW OLD AS OLD", int64(2), "BEFORE INSERT ON ORDERS\n"},
+ {"PLAIN_TRG", "INSERT", "BEFORE EACH ROW", "PLAIN_TRG\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\n", "ENABLED", nil, "REFERENCING NEW AS NEW OLD AS OLD", int64(3), "FOR EACH ROW\n"},
+ {"PLAIN_TRG", "INSERT", "BEFORE EACH ROW", "PLAIN_TRG\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\n", "ENABLED", nil, "REFERENCING NEW AS NEW OLD AS OLD", int64(4), "BEGIN NULL; END;\n"},
+ {"WHEN_TRG", "INSERT", "BEFORE EACH ROW", "WHEN_TRG\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\n", "ENABLED", "NEW.STATUS = 'OPEN'", "REFERENCING NEW AS NEW OLD AS OLD", int64(1), "TRIGGER WHEN_TRG\n"},
+ {"WHEN_TRG", "INSERT", "BEFORE EACH ROW", "WHEN_TRG\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\n", "ENABLED", "NEW.STATUS = 'OPEN'", "REFERENCING NEW AS NEW OLD AS OLD", int64(2), "BEFORE INSERT ON ORDERS\n"},
+ {"WHEN_TRG", "INSERT", "BEFORE EACH ROW", "WHEN_TRG\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\n", "ENABLED", "NEW.STATUS = 'OPEN'", "REFERENCING NEW AS NEW OLD AS OLD", int64(3), "FOR EACH ROW\n"},
+ {"WHEN_TRG", "INSERT", "BEFORE EACH ROW", "WHEN_TRG\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\n", "ENABLED", "NEW.STATUS = 'OPEN'", "REFERENCING NEW AS NEW OLD AS OLD", int64(4), "WHEN (NEW.STATUS = 'OPEN')\n"},
+ {"WHEN_TRG", "INSERT", "BEFORE EACH ROW", "WHEN_TRG\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\n", "ENABLED", "NEW.STATUS = 'OPEN'", "REFERENCING NEW AS NEW OLD AS OLD", int64(5), "BEGIN NULL; END;\n"},
+ },
+ },
+ })
+ s := newServer()
+ s.db = db
+
+ triggers, err := s.listTriggers(schema, table)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(triggers) != 2 || triggers[0].Statement == nil || triggers[1].Statement == nil {
+ t.Fatalf("listTriggers = %#v, want two triggers with source", triggers)
+ }
+ if got := *triggers[0].Statement; got != "BEGIN NULL; END;" {
+ t.Fatalf("plain trigger statement = %q, want stripped body", got)
+ }
+ if got := *triggers[1].Statement; !strings.HasPrefix(got, "TRIGGER WHEN_TRG\n") || !strings.Contains(got, "WHEN (NEW.STATUS = 'OPEN')") {
+ t.Fatalf("WHEN trigger statement = %q, want full declaration kept", got)
+ }
+ if triggers[0].Enabled == nil || !*triggers[0].Enabled {
+ t.Fatalf("plain trigger enabled = %v, want true", triggers[0].Enabled)
+ }
+}
+
+func TestOracleTriggerIsStructured(t *testing.T) {
+ const description = "AUDIT_TRG\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\n"
+ const defaultReferencing = "REFERENCING NEW AS NEW OLD AS OLD"
+ if !oracleTriggerIsStructured(description, "", defaultReferencing) {
+ t.Fatal("plain row trigger should be structured")
+ }
+ if !oracleTriggerIsStructured("AUDIT_TRG\nAFTER INSERT ON ORDERS\n", "", "") {
+ t.Fatal("statement trigger without referencing names should be structured")
+ }
+ if oracleTriggerIsStructured(description, "NEW.ID > 0", defaultReferencing) {
+ t.Fatal("WHEN condition should not be structured")
+ }
+ if oracleTriggerIsStructured(description, "", "REFERENCING NEW AS N OLD AS O") {
+ t.Fatal("custom REFERENCING names should not be structured")
+ }
+ if oracleTriggerIsStructured("AUDIT_TRG\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\nFOLLOWS OTHER_TRG\n", "", defaultReferencing) {
+ t.Fatal("FOLLOWS ordering should not be structured")
+ }
+}
+
func TestOracleTriggerBodyFallsBackToVisibleSource(t *testing.T) {
body, ok := oracleTriggerBody("TRIGGER APP.AUDIT\nBEGIN\n NULL;\nEND;\n", "differently formatted declaration")
if !ok {
diff --git a/apps/desktop/src/components/structure/TableStructureEditor.vue b/apps/desktop/src/components/structure/TableStructureEditor.vue
index 2ed176ea94..ea96082896 100644
--- a/apps/desktop/src/components/structure/TableStructureEditor.vue
+++ b/apps/desktop/src/components/structure/TableStructureEditor.vue
@@ -1012,7 +1012,7 @@ function foreignKeyChanged(foreignKey: EditableStructureForeignKey): boolean {
function triggerChanged(trigger: EditableStructureTrigger): boolean {
if (!trigger.original || trigger.markedForDrop) return true;
const original = trigger.original;
- return trigger.name !== original.name || trigger.timing !== original.timing || trigger.event !== original.event || !sameText(trigger.statement, original.statement);
+ return trigger.name !== original.name || trigger.timing !== original.timing || trigger.event !== original.event || !sameText(trigger.statement, original.statement) || (trigger.enabled !== undefined && trigger.enabled !== original.enabled);
}
function captureStructureRefreshScope(): TableStructureRefreshScope {
@@ -5150,6 +5150,7 @@ function addTrigger() {
timing: isOracleTriggerEditor.value ? "BEFORE EACH ROW" : isSqlServerTriggerEditor.value ? "AFTER" : "BEFORE",
event: "INSERT",
statement: isOracleTriggerEditor.value ? "BEGIN\n NULL;\nEND" : isSqlServerTriggerEditor.value ? "BEGIN\n SET NOCOUNT ON;\nEND" : "BEGIN\n \nEND",
+ enabled: true,
markedForDrop: false,
};
triggers.value.push(draft);
@@ -5166,7 +5167,13 @@ function toggleDropTrigger(trigger: EditableStructureTrigger) {
}
function canEditTriggerDraft(trigger: EditableStructureTrigger): boolean {
- return !triggersLoading.value && canEditTriggers.value && !trigger.markedForDrop && canEditStructuredTriggerDraft(databaseType.value, trigger);
+ return canToggleTriggerEnabled(trigger) && canEditStructuredTriggerDraft(databaseType.value, trigger);
+}
+
+// ALTER TRIGGER ... ENABLE/DISABLE leaves the source untouched, so it stays available for
+// triggers whose source the structured form cannot rebuild.
+function canToggleTriggerEnabled(trigger: EditableStructureTrigger): boolean {
+ return !triggersLoading.value && canEditTriggers.value && !trigger.markedForDrop;
}
function primarySqlOperation(sql: string): string {
@@ -7016,8 +7023,18 @@ watch(
<SelectItem v-for="event in triggerEventOptions" :key="event" :value="event">{{ event }}</SelectItem>
</SelectContent>
</Select>
- <Badge v-if="trigger.original && trigger.original.enabled !== undefined && trigger.original.enabled !== null" variant="outline" class="shrink-0 text-[length:var(--structure-font-size)]">
- {{ trigger.original.enabled ? t("damengJobAdmin.enabled") : t("damengJobAdmin.disabled") }}
+ <Button
+ v-if="isOracleTriggerEditor && trigger.enabled !== undefined"
+ variant="outline"
+ size="sm"
+ :class="['h-[var(--structure-control-height)] shrink-0 px-[var(--structure-control-px)] text-[length:var(--structure-font-size)]', !trigger.enabled ? 'text-muted-foreground' : '']"
+ :disabled="!canToggleTriggerEnabled(trigger)"
+ @click.stop="trigger.enabled = !trigger.enabled"
+ >
+ {{ trigger.enabled ? t("damengJobAdmin.enabled") : t("damengJobAdmin.disabled") }}
+ </Button>
+ <Badge v-else-if="trigger.enabled !== undefined && trigger.enabled !== null" variant="outline" class="shrink-0 text-[length:var(--structure-font-size)]">
+ {{ trigger.enabled ? t("damengJobAdmin.enabled") : t("damengJobAdmin.disabled") }}
</Badge>
<Button v-if="trigger.original" variant="ghost" size="sm" :class="structureToolbarButtonClass" @click.stop="toggleDropTrigger(trigger)">
<Trash2 :class="structureIconClass" />
diff --git a/apps/desktop/src/lib/__tests__/table/tableStructureEditorState.spec.ts b/apps/desktop/src/lib/__tests__/table/tableStructureEditorState.spec.ts
index 0b4a2558d1..1fba7f2b38 100644
--- a/apps/desktop/src/lib/__tests__/table/tableStructureEditorState.spec.ts
+++ b/apps/desktop/src/lib/__tests__/table/tableStructureEditorState.spec.ts
@@ -368,11 +368,18 @@ describe("tableStructureEditorState", () => {
});
});
- it("keeps existing Oracle trigger drafts read-only until full source editing is available", () => {
- const [existing] = createTriggerDrafts([{ name: "ORDERS_AUDIT", timing: "AFTER EACH ROW", event: "INSERT OR UPDATE", statement: "BEGIN NULL; END;" }]);
- if (!existing) throw new Error("expected an existing trigger draft");
+ it("allows existing Oracle trigger drafts to be edited only when the source is a plain body", () => {
+ const [existing, unstructured, missingSource] = createTriggerDrafts([
+ { name: "ORDERS_AUDIT", timing: "AFTER EACH ROW", event: "INSERT OR UPDATE", statement: "BEGIN NULL; END;", enabled: false },
+ { name: "ORDERS_WHEN", timing: "BEFORE EACH ROW", event: "INSERT", statement: "TRIGGER ORDERS_WHEN\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\nWHEN (NEW.ID > 0)\nBEGIN NULL; END;" },
+ { name: "ORDERS_EMPTY", timing: "BEFORE EACH ROW", event: "INSERT" },
+ ]);
+ if (!existing || !unstructured || !missingSource) throw new Error("expected existing trigger drafts");
- expect(canEditStructuredTriggerDraft("oracle", existing)).toBe(false);
+ expect(existing.enabled).toBe(false);
+ expect(canEditStructuredTriggerDraft("oracle", existing)).toBe(true);
+ expect(canEditStructuredTriggerDraft("oracle", unstructured)).toBe(false);
+ expect(canEditStructuredTriggerDraft("oracle", missingSource)).toBe(false);
expect(canEditStructuredTriggerDraft(undefined, existing)).toBe(false);
expect(canEditStructuredTriggerDraft("mysql", existing)).toBe(true);
expect(canEditStructuredTriggerDraft("sqlserver", existing)).toBe(true);
diff --git a/apps/desktop/src/lib/table/tableStructureEditorSql.ts b/apps/desktop/src/lib/table/tableStructureEditorSql.ts
index 49b0e7de0f..2b038d7fbf 100644
--- a/apps/desktop/src/lib/table/tableStructureEditorSql.ts
+++ b/apps/desktop/src/lib/table/tableStructureEditorSql.ts
@@ -80,6 +80,7 @@ export interface EditableStructureTrigger {
timing: string;
event: string;
statement: string;
+ enabled?: boolean;
original?: TriggerInfo;
markedForDrop: boolean;
}
diff --git a/apps/desktop/src/lib/table/tableStructureEditorState.ts b/apps/desktop/src/lib/table/tableStructureEditorState.ts
index ad3b54ff77..601da591bb 100644
--- a/apps/desktop/src/lib/table/tableStructureEditorState.ts
+++ b/apps/desktop/src/lib/table/tableStructureEditorState.ts
@@ -1343,13 +1343,23 @@ export function createTriggerDrafts(triggers: TriggerInfo[]): EditableStructureT
timing: trigger.timing,
event: trigger.event,
statement: trigger.statement ?? "",
+ enabled: trigger.enabled ?? undefined,
original: trigger,
markedForDrop: false,
}));
}
export function canEditStructuredTriggerDraft(databaseType: DatabaseType | undefined, trigger: EditableStructureTrigger): boolean {
- return !trigger.original || (databaseType !== undefined && databaseType !== "oracle");
+ if (!trigger.original) return true;
+ if (databaseType === undefined) return false;
+ // The Oracle driver keeps the `TRIGGER ...` declaration when the source has clauses (WHEN,
+ // REFERENCING, FOLLOWS, ...) that the timing/event/body form would drop on CREATE OR REPLACE.
+ return databaseType !== "oracle" || isStructuredOracleTriggerSource(trigger.original.statement);
+}
+
+function isStructuredOracleTriggerSource(statement: string | null | undefined): boolean {
+ const source = statement?.trim() ?? "";
+ return source !== "" && !/^(?:CREATE\s+(?:OR\s+REPLACE\s+)?)?(?:(?:EDITIONABLE|NONEDITIONABLE)\s+)?TRIGGER\b/i.test(source);
}
export function toColumnNames(columns: string[]): string {
diff --git a/crates/dbx-sql-schema/src/table_structure_sql/tests.rs b/crates/dbx-sql-schema/src/table_structure_sql/tests.rs
index 647b78610e..5837adf53e 100644
--- a/crates/dbx-sql-schema/src/table_structure_sql/tests.rs
+++ b/crates/dbx-sql-schema/src/table_structure_sql/tests.rs
@@ -489,6 +489,7 @@ fn trigger(name: &str, timing: &str, event: &str, statement: &str) -> EditableSt
timing: timing.to_string(),
event: event.to_string(),
statement: statement.to_string(),
+ enabled: None,
original: None,
marked_for_drop: false,
}
@@ -7451,8 +7452,140 @@ fn changed_postgres_trigger_remains_unsupported() {
assert_eq!(result.warnings, vec!["Editing triggers is not supported for postgres from this editor."]);
}
+fn trigger_change_sql(
+ database_type: DatabaseType,
+ schema: &str,
+ table_name: &str,
+ triggers: Vec<EditableStructureTrigger>,
+) -> TableStructureSqlResult {
+ build_table_structure_change_sql(TableStructureSqlOptions {
+ database_type: Some(database_type),
+ driver_profile: None,
+ schema: Some(schema.to_string()),
+ table_name: table_name.to_string(),
+ columns: Vec::new(),
+ indexes: Vec::new(),
+ foreign_keys: Vec::new(),
+ triggers,
+ table_comment: None,
+ original_table_comment: None,
+ mysql_engine: None,
+ mysql_auto_increment_value: None,
+ transwarp_create: None,
+ partitioned: false,
+ foreign_table: false,
+ is_gaussdb_m_mode: false,
+ table_collation: None,
+ primary_key_name: None,
+ })
+}
+
+fn existing_trigger(
+ name: &str,
+ timing: &str,
+ event: &str,
+ statement: &str,
+ enabled: Option<bool>,
+) -> EditableStructureTrigger {
+ let mut existing = trigger(name, timing, event, statement);
+ existing.enabled = enabled;
+ existing.original = Some(TriggerInfo {
+ name: name.to_string(),
+ event: event.to_string(),
+ timing: timing.to_string(),
+ statement: Some(statement.to_string()),
+ enabled,
+ });
+ existing
+}
+
+#[test]
+fn oracle_trigger_enabled_toggle_emits_alter_trigger() {
+ let mut disable = existing_trigger("ORDERS_AUDIT", "AFTER EACH ROW", "INSERT", "BEGIN NULL; END;", Some(true));
+ disable.enabled = Some(false);
+ let mut enable = existing_trigger("ORDERS_CHECK", "BEFORE EACH ROW", "UPDATE", "BEGIN NULL; END;", Some(false));
+ enable.enabled = Some(true);
+
+ let result = trigger_change_sql(DatabaseType::Oracle, "APP", "ORDERS", vec![disable, enable]);
+
+ assert_eq!(
+ result.statements,
+ vec!["ALTER TRIGGER \"APP\".\"ORDERS_AUDIT\" DISABLE;", "ALTER TRIGGER \"APP\".\"ORDERS_CHECK\" ENABLE;",]
+ );
+ assert!(result.warnings.is_empty());
+}
+
+#[test]
+fn oracle_trigger_body_edit_restores_disabled_state() {
+ let mut existing = existing_trigger("ORDERS_AUDIT", "AFTER EACH ROW", "INSERT", "BEGIN NULL; END;", Some(false));
+ existing.statement = "BEGIN\n DBMS_OUTPUT.PUT_LINE('x');\nEND;".to_string();
+
+ let result = trigger_change_sql(DatabaseType::Oracle, "APP", "ORDERS", vec![existing]);
+
+ assert_eq!(
+ result.statements,
+ vec![
+ "CREATE OR REPLACE TRIGGER \"APP\".\"ORDERS_AUDIT\" AFTER INSERT ON \"APP\".\"ORDERS\"\nFOR EACH ROW\nBEGIN\n DBMS_OUTPUT.PUT_LINE('x');\nEND;",
+ "ALTER TRIGGER \"APP\".\"ORDERS_AUDIT\" DISABLE;",
+ ]
+ );
+}
+
#[test]
-fn rejects_editing_existing_oracle_trigger_without_complete_source() {
+fn rejects_editing_oracle_trigger_with_unstructured_source() {
+ let source =
+ "TRIGGER ORDERS_AUDIT\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\nWHEN (NEW.STATUS = 'OPEN')\nBEGIN NULL; END;";
+ let mut edited = existing_trigger("ORDERS_AUDIT", "BEFORE EACH ROW", "INSERT", source, Some(true));
+ edited.event = "INSERT OR UPDATE".to_string();
+ let mut renamed = existing_trigger("ORDERS_CHECK", "BEFORE EACH ROW", "INSERT", source, Some(true));
+ renamed.name = "ORDERS_CHECK_V2".to_string();
+
+ let result = trigger_change_sql(DatabaseType::Oracle, "APP", "ORDERS", vec![edited, renamed]);
+
+ assert!(result.statements.is_empty(), "unexpected statements: {:?}", result.statements);
+ assert_eq!(
+ result.warnings,
+ vec![
+ "Editing existing Oracle trigger \"ORDERS_AUDIT\" requires its complete source definition.",
+ "Editing existing Oracle trigger \"ORDERS_CHECK\" requires its complete source definition.",
+ ]
+ );
+}
+
+#[test]
+fn oracle_trigger_with_unstructured_source_can_still_toggle_enabled() {
+ let source =
+ "TRIGGER ORDERS_AUDIT\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\nWHEN (NEW.STATUS = 'OPEN')\nBEGIN NULL; END;";
+ let mut existing = existing_trigger("ORDERS_AUDIT", "BEFORE EACH ROW", "INSERT", source, Some(true));
+ existing.enabled = Some(false);
+
+ let result = trigger_change_sql(DatabaseType::Oracle, "APP", "ORDERS", vec![existing]);
+
+ assert_eq!(result.statements, vec!["ALTER TRIGGER \"APP\".\"ORDERS_AUDIT\" DISABLE;"]);
+ assert!(result.warnings.is_empty());
+}
+
+#[test]
+fn sqlserver_trigger_enabled_toggle_emits_enable_disable_trigger() {
+ let mut disable = existing_trigger("orders_audit", "AFTER", "INSERT", "BEGIN SET NOCOUNT ON; END", Some(true));
+ disable.enabled = Some(false);
+ let mut enable = existing_trigger("orders_check", "AFTER", "UPDATE", "BEGIN SET NOCOUNT ON; END", Some(false));
+ enable.enabled = Some(true);
+
+ let result = trigger_change_sql(DatabaseType::SqlServer, "dbo", "orders", vec![disable, enable]);
+
+ assert_eq!(
+ result.statements,
+ vec![
+ "DISABLE TRIGGER [dbo].[orders_audit] ON [dbo].[orders];",
+ "ENABLE TRIGGER [dbo].[orders_check] ON [dbo].[orders];",
+ ]
+ );
+ assert!(result.warnings.is_empty());
+}
+
+#[test]
+fn allows_editing_existing_oracle_trigger() {
let mut existing = trigger(
"DBX_TRIGGER_4320_AUDIT",
"AFTER EACH ROW",
@@ -7488,11 +7621,13 @@ fn rejects_editing_existing_oracle_trigger_without_complete_source() {
primary_key_name: None,
});
- assert!(result.statements.is_empty());
assert_eq!(
- result.warnings,
- vec!["Editing existing Oracle trigger \"DBX_TRIGGER_4320_AUDIT\" requires its complete source definition."]
+ result.statements,
+ vec![
+ "CREATE OR REPLACE TRIGGER \"APP\".\"DBX_TRIGGER_4320_AUDIT\" AFTER INSERT OR UPDATE OR DELETE ON \"APP\".\"DBX_TRIGGER_4320\"\nFOR EACH ROW\nDECLARE\n v_event VARCHAR2(10);\nBEGIN\n v_event := CASE WHEN INSERTING THEN 'INSERT' WHEN UPDATING THEN 'UPDATE' ELSE 'DELETE' END;\nEND;"
+ ]
);
+ assert!(result.warnings.is_empty());
}
#[test]
diff --git a/crates/dbx-sql-schema/src/table_structure_sql/triggers.rs b/crates/dbx-sql-schema/src/table_structure_sql/triggers.rs
index 2591426293..d04e951faf 100644
--- a/crates/dbx-sql-schema/src/table_structure_sql/triggers.rs
+++ b/crates/dbx-sql-schema/src/table_structure_sql/triggers.rs
@@ -46,44 +46,79 @@ fn build_trigger_sql_with_mode(
continue;
}
+ let mut needs_recreate = trigger.original.is_none();
+ let mut needs_alter_enabled = false;
+
if let Some(original) = &trigger.original {
- if dialect == StructureDialect::Oracle {
- if has_trigger_change(trigger, original) {
+ if !has_trigger_change(trigger, original) {
+ continue;
+ }
+
+ if has_trigger_body_change(trigger, original) {
+ if dialect == StructureDialect::Oracle && !is_structured_oracle_trigger_source(original) {
+ // The stored source carries clauses (WHEN, REFERENCING, FOLLOWS, ...) that the
+ // timing/event/body form cannot represent, so CREATE OR REPLACE would drop them.
warnings.push(format!(
"Editing existing Oracle trigger \"{}\" requires its complete source definition.",
original.name
));
+ continue;
}
- continue;
- }
- if !has_trigger_change(trigger, original) {
- continue;
- }
- // Oracle can replace a trigger in place; renames still require dropping the old object.
- if dialect != StructureDialect::Oracle || clean(&trigger.name) != clean(&original.name) {
- statements.push(drop_trigger_sql(dialect, options.schema.as_deref(), &original.name));
+ needs_recreate = true;
+ // Oracle can replace a trigger in place; renames still require dropping the old object.
+ if dialect != StructureDialect::Oracle || clean(&trigger.name) != clean(&original.name) {
+ statements.push(drop_trigger_sql(dialect, options.schema.as_deref(), &original.name));
+ }
+ } else if trigger.enabled.is_some() && trigger.enabled != original.enabled {
+ needs_alter_enabled = true;
}
}
- if let Some(sql) = create_trigger_sql(
- options.database_type,
- dialect,
- options.schema.as_deref(),
- &table,
- trigger,
- warnings,
- for_new_table,
- ) {
- statements.push(sql);
- // SQL Server rebuilds via DROP + CREATE, which resets is_disabled to
- // enabled; restore the catalog-reported disabled state explicitly.
- // `table` is already qualified the same way the CREATE's ON clause is.
- if dialect == StructureDialect::SqlServer
- && trigger.original.as_ref().is_some_and(|original| original.enabled == Some(false))
- {
+ if needs_recreate {
+ if let Some(sql) = create_trigger_sql(
+ options.database_type,
+ dialect,
+ options.schema.as_deref(),
+ &table,
+ trigger,
+ warnings,
+ for_new_table,
+ ) {
+ statements.push(sql);
+ // SQL Server rebuilds via DROP + CREATE, which resets is_disabled to
+ // enabled; restore the catalog-reported disabled state explicitly.
+ // `table` is already qualified the same way the CREATE's ON clause is.
+ if dialect == StructureDialect::SqlServer {
+ let enabled = trigger
+ .enabled
+ .unwrap_or_else(|| trigger.original.as_ref().and_then(|o| o.enabled).unwrap_or(true));
+ if !enabled {
+ let schema = options.schema.as_deref();
+ let trigger_name = qualified_trigger_object_name(dialect, schema, &trigger.name);
+ statements.push(format!("DISABLE TRIGGER {trigger_name} ON {table};"));
+ }
+ } else if dialect == StructureDialect::Oracle {
+ let enabled = trigger
+ .enabled
+ .unwrap_or_else(|| trigger.original.as_ref().and_then(|o| o.enabled).unwrap_or(true));
+ if !enabled {
+ let schema = options.schema.as_deref();
+ let trigger_name = qualified_trigger_object_name(dialect, schema, &trigger.name);
+ statements.push(format!("ALTER TRIGGER {trigger_name} DISABLE;"));
+ }
+ }
+ }
+ } else if needs_alter_enabled {
+ if dialect == StructureDialect::Oracle {
+ let schema = options.schema.as_deref();
+ let trigger_name = qualified_trigger_object_name(dialect, schema, &trigger.name);
+ let state = if trigger.enabled == Some(true) { "ENABLE" } else { "DISABLE" };
+ statements.push(format!("ALTER TRIGGER {trigger_name} {state};"));
+ } else if dialect == StructureDialect::SqlServer {
let schema = options.schema.as_deref();
let trigger_name = qualified_trigger_object_name(dialect, schema, &trigger.name);
- statements.push(format!("DISABLE TRIGGER {trigger_name} ON {table};"));
+ let state = if trigger.enabled == Some(true) { "ENABLE" } else { "DISABLE" };
+ statements.push(format!("{state} TRIGGER {trigger_name} ON {table};"));
}
}
}
@@ -104,6 +139,15 @@ fn has_trigger_edit(trigger: &EditableStructureTrigger) -> bool {
}
fn has_trigger_change(trigger: &EditableStructureTrigger, original: &TriggerInfo) -> bool {
+ let has_body_change = clean(&trigger.name) != clean(&original.name)
+ || normalize_keyword(&trigger.timing) != normalize_keyword(&original.timing)
+ || normalize_keyword(&trigger.event) != normalize_keyword(&original.event)
+ || normalize_statement(&trigger.statement) != normalize_statement(original.statement.as_deref().unwrap_or(""));
+ let has_enabled_change = trigger.enabled.is_some() && trigger.enabled != original.enabled;
+ has_body_change || has_enabled_change
+}
+
+fn has_trigger_body_change(trigger: &EditableStructureTrigger, original: &TriggerInfo) -> bool {
clean(&trigger.name) != clean(&original.name)
|| normalize_keyword(&trigger.timing) != normalize_keyword(&original.timing)
|| normalize_keyword(&trigger.event) != normalize_keyword(&original.event)
@@ -327,6 +371,13 @@ fn create_oracle_trigger_sql(
))
}
+/// The driver strips the dictionary declaration only when the trigger is fully described by its
+/// timing, event and body; otherwise the source still starts with `TRIGGER ...`.
+fn is_structured_oracle_trigger_source(original: &TriggerInfo) -> bool {
+ let statement = original.statement.as_deref().unwrap_or("").trim();
+ !statement.is_empty() && !starts_with_trigger_declaration(statement)
+}
+
/// Oracle triggers come back from the driver as `ALL_SOURCE` text. When the dictionary declaration
/// and the stored source cannot be aligned line by line — a trigger written on a single line — the
/// raw source is returned instead of the body, and appending it after our own `FOR EACH ROW`
diff --git a/crates/dbx-sql-schema/src/table_structure_sql/types.rs b/crates/dbx-sql-schema/src/table_structure_sql/types.rs
index de2d012fac..72444f6840 100644
--- a/crates/dbx-sql-schema/src/table_structure_sql/types.rs
+++ b/crates/dbx-sql-schema/src/table_structure_sql/types.rs
@@ -211,6 +211,8 @@ pub struct EditableStructureTrigger {
#[serde(default)]
pub statement: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
+ pub enabled: Option<bool>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
pub original: Option<TriggerInfo>,
#[serde(default)]
pub marked_for_drop: bool,