Add support for 'OnUpdate'

Author: ting-lan-wang

oracle/migrator.go

@@ -145,6 +145,17 @@ func (m Migrator) CreateTable(values ...interface{}) error {
 					}
 					if constraint := rel.ParseConstraint(); constraint != nil {
 						if constraint.Schema == stmt.Schema {
+							// Oracle doesn’t support OnUpdate on foreign keys.
+							// Use a trigger instead to propagate the update to the child table instead.
+							if len(constraint.References) > 0 && constraint.OnUpdate != "" {
+								constraint.OnUpdate = ""
+								defer func(tx *gorm.DB, table string, constraint *schema.Constraint) {
+									if err == nil {
+										err = m.createUpadateCascadeTrigger(tx, constraint)
+									}
+								}(tx, stmt.Table, constraint)
+							}
+
 							// If the same set of foreign keys already references the parent column,
 							// remove duplicates to avoid ORA-02274: duplicate referential constraint specifications
 							var foreignKeys []string
@@ -399,6 +410,32 @@ func (m Migrator) ColumnTypes(value interface{}) ([]gorm.ColumnType, error) {
 	return columnTypes, execErr
 }
 
+// CreateConstraint creates constraint based on the given 'value' and 'name'
+func (m Migrator) CreateConstraint(value interface{}, name string) error {
+	return m.RunWithValue(value, func(stmt *gorm.Statement) error {
+		constraint, table := m.GuessConstraintInterfaceAndTable(stmt, name)
+		if constraint != nil {
+			if c, ok := constraint.(*schema.Constraint); ok {
+				// Oracle doesn’t support OnUpdate on foreign keys.
+				// Use a trigger instead to propagate the update to the child table instead.
+				if len(c.References) > 0 && c.OnUpdate != "" {
+					c.OnUpdate = ""
+					constraint = c
+					m.createUpadateCascadeTrigger(m.DB, c)
+				}
+			}
+
+			vars := []interface{}{clause.Table{Name: table}}
+			if stmt.TableExpr != nil {
+				vars[0] = stmt.TableExpr
+			}
+			sql, values := constraint.Build()
+			return m.DB.Exec("ALTER TABLE ? ADD "+sql, append(vars, values...)...).Error
+		}
+		return nil
+	})
+}
+
 // HasConstraint checks whether the table for the given `value` contains the specified constraint `name`
 func (m Migrator) HasConstraint(value interface{}, name string) bool {
 	var count int64
@@ -418,6 +455,33 @@ func (m Migrator) HasConstraint(value interface{}, name string) bool {
 	return count > 0
 }
 
+// DropConstraint drops constraint based on the given 'value' and 'name'
+func (m Migrator) DropConstraint(value interface{}, name string) error {
+	if err := m.RunWithValue(value, func(stmt *gorm.Statement) error {
+
+		constraint, _ := m.GuessConstraintInterfaceAndTable(stmt, name)
+
+		if c, ok := constraint.(*schema.Constraint); ok && c != nil {
+			if len(c.References) > 0 && c.OnUpdate != "" {
+				for i, fk := range c.ForeignKeys {
+					triggerName := m.FkTriggerName(
+						c.ReferenceSchema.Table,
+						c.References[i].DBName,
+						c.Schema.Table,
+						fk.DBName,
+					)
+					return m.DB.Exec("DROP TRIGGER ?", clause.Column{Name: triggerName}).Error
+				}
+			}
+		}
+		return nil
+	}); err != nil {
+		return err
+	}
+
+	return m.Migrator.DropConstraint(value, name)
+}
+
 // DropIndex drops the index with the specified `name` from the table associated with `value`
 func (m Migrator) DropIndex(value interface{}, name string) error {
 	return m.RunWithValue(value, func(stmt *gorm.Statement) error {
@@ -569,3 +633,65 @@ func (m Migrator) isNumeric(s string) bool {
 	_, err := strconv.ParseFloat(s, 64)
 	return err == nil
 }
+
+func (m Migrator) FkTriggerName(refTable string, refField string, table string, field string) string {
+	return fmt.Sprintf("fk_trigger_%s_%s_%s_%s", refTable, refField, table, field)
+}
+
+// Creates a trigger to cascade the update to the child table
+func (m Migrator) createUpadateCascadeTrigger(tx *gorm.DB, constraint *schema.Constraint) error {
+	for i, fk := range constraint.ForeignKeys {
+		var (
+			tmpBuilder   strings.Builder
+			plsqlBuilder strings.Builder
+			parentTable  string = constraint.ReferenceSchema.Table
+			parentField  string = constraint.References[i].DBName
+			table        string = constraint.Schema.Table
+			field        string = fk.DBName
+
+			triggerName string = m.FkTriggerName(parentTable, parentField, table, field)
+
+			quotedParentTable string
+			quotedParentField string
+			quotedTable       string
+			quotedField       string
+			quotedTriggerName string
+		)
+
+		// Initialize quoted variables according to the driver’s quoting rules
+		writeQuotedIdentifier(&tmpBuilder, parentTable)
+		quotedParentTable = tmpBuilder.String()
+		tmpBuilder.Reset()
+
+		writeQuotedIdentifier(&tmpBuilder, parentField)
+		quotedParentField = tmpBuilder.String()
+		tmpBuilder.Reset()
+
+		writeQuotedIdentifier(&tmpBuilder, table)
+		quotedTable = tmpBuilder.String()
+		tmpBuilder.Reset()
+
+		writeQuotedIdentifier(&tmpBuilder, field)
+		quotedField = tmpBuilder.String()
+		tmpBuilder.Reset()
+
+		writeQuotedIdentifier(&tmpBuilder, triggerName)
+		quotedTriggerName = tmpBuilder.String()
+		tmpBuilder.Reset()
+
+		// Start PL/SQL block
+		plsqlBuilder.WriteString("CREATE OR REPLACE TRIGGER " + quotedTriggerName + "\n")
+		plsqlBuilder.WriteString("AFTER UPDATE OF " + quotedParentField + " ON " + quotedParentTable + "\n")
+		plsqlBuilder.WriteString("FOR EACH ROW\n")
+		plsqlBuilder.WriteString("BEGIN\n")
+		plsqlBuilder.WriteString("  UPDATE " + quotedTable + "\n")
+		plsqlBuilder.WriteString("  SET " + quotedField + " = :NEW." + quotedParentField + "\n")
+		plsqlBuilder.WriteString("  WHERE " + quotedField + " = :OLD." + quotedParentField)
+		plsqlBuilder.WriteString(";\n")
+		plsqlBuilder.WriteString("END;")
+		if err := tx.Exec(plsqlBuilder.String()).Error; err != nil {
+			return err
+		}
+	}
+	return nil
+}

tests/associations_test.go

@@ -112,7 +112,6 @@ func TestAssociationNotNullClear(t *testing.T) {
 }
 
 func TestForeignKeyConstraints(t *testing.T) {
-	t.Skip()
 	type Profile struct {
 		ID       uint
 		Name     string
@@ -121,7 +120,7 @@ func TestForeignKeyConstraints(t *testing.T) {
 
 	type Member struct {
 		ID      uint
-		Refer   uint `gorm:"uniqueIndex"`
+		Refer   uint `gorm:"unique"`
 		Name    string
 		Profile Profile `gorm:"Constraint:OnUpdate:CASCADE,OnDelete:CASCADE;FOREIGNKEY:MemberID;References:Refer"`
 	}
@@ -168,11 +167,10 @@ func TestForeignKeyConstraints(t *testing.T) {
 }
 
 func TestForeignKeyConstraintsBelongsTo(t *testing.T) {
-	t.Skip()
 	type Profile struct {
 		ID    uint
 		Name  string
-		Refer uint `gorm:"uniqueIndex"`
+		Refer uint `gorm:"unique"`
 	}
 
 	type Member struct {

tests/go.mod

@@ -5,15 +5,15 @@ go 1.24.4
 require gorm.io/gorm v1.30.0
 
 require (
-	github.com/oracle-samples/gorm-oracle v0.0.1
+	github.com/godror/godror v0.49.0
+	github.com/oracle-samples/gorm-oracle v0.1.0
 	github.com/stretchr/testify v1.10.0
 )
 
 require (
 	github.com/VictoriaMetrics/easyproto v0.1.4 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/go-logfmt/logfmt v0.6.0 // indirect
-	github.com/godror/godror v0.49.0 // indirect
 	github.com/godror/knownpb v0.3.0 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect

tests/migrate_test.go

@@ -1721,3 +1721,59 @@ func TestAutoMigrateDecimal(t *testing.T) {
 		decimalColumnsTest[MigrateDecimalColumn, MigrateDecimalColumn2](t, expectedSql)
 	}
 }
+
+func TestMigrateOnUpdateConstraint(t *testing.T) {
+	type Owner struct {
+		ID   int
+		Name string
+	}
+
+	type Pen struct {
+		gorm.Model
+		OwnerID int
+		Owner   Owner `gorm:"constraint:OnUpdate:CASCADE,OnDelete:SET NULL;"`
+	}
+
+	DB.Migrator().DropTable(&Pen{}, &Owner{})
+
+	// Verify the trigger is created using CreateTable()
+	if err := DB.Migrator().CreateTable(&Owner{}, &Pen{}); err != nil {
+		t.Fatalf("Failed to create table, got error: %v", err)
+	}
+
+	triggerName := "fk_trigger_owners_id_pens_owner_id"
+
+	var count int
+	DB.Raw("SELECT count(*) FROM user_triggers where trigger_name = ?", triggerName).Scan(&count)
+	if count != 1 {
+		t.Errorf("Should find the trigger %s", triggerName)
+	}
+
+	// Verify the trigger is created using CreateConstraint()
+	constraintName := "fk_pens_owner"
+	if err := DB.Migrator().DropConstraint(&Pen{}, constraintName); err != nil {
+		t.Errorf("failed to drop constraint %v, got error %v", constraintName, err)
+	}
+
+	if err := DB.Migrator().CreateConstraint(&Pen{}, constraintName); err != nil {
+		t.Errorf("failed to create constraint %v, got error %v", constraintName, err)
+	}
+
+	DB.Raw("SELECT count(*) FROM user_triggers where trigger_name = ?", triggerName).Scan(&count)
+	if count != 1 {
+		t.Errorf("Should find the trigger %s", triggerName)
+	}
+
+	// Verify the trigger works
+	user := Pen{Owner: Owner{ID: 1, Name: "John"}}
+	DB.Create(&user)
+
+	DB.Model(user.Owner).Update("id", 100)
+
+	var user2 Pen
+	if err := DB.First(&user2, "\"id\" = ?", user.ID).Error; err != nil {
+		panic(fmt.Errorf("failed to find member, got error: %v", err))
+	} else if user2.OwnerID != 100 {
+		panic(fmt.Errorf("company id is not equal: expects: %v, got: %v", 100, user2.OwnerID))
+	}
+}