我的数据库中有一个层次模型(一个团队有客户，每个客户都可以有注释)。如果团队被删除，我的目标是能够清理数据库: -> 删除团队 -> 删除所有客户 -> 删除每个客户的所有备注

我的计划是通过 BeforeDelete 回调来完成，但是在团队回调之后，不再正确调用 Customers 的 BeforeDelete。 在数据库中，团队及其客户被删除，但客户的注释没有。也不打印日志行。

您知道是否可以链接这些回调，或者是设计不执行第二个回调。

package main

import (
   "errors"
    "log"
    "github.com/jinzhu/gorm"
  _ "github.com/jinzhu/gorm/dialects/sqlite"
)

var DB *gorm.DB

type Team struct {
   gorm.Model
   Name      string
   Customers []Customer
}

type Note struct {
    gorm.Model
    Content   string
    OwnerID   uint
    OwnerType string
}

type Customer struct {
   gorm.Model
   Name   string
   TeamID uint
   Notes  []Note `gorm:"polymorphic:Owner;"`
}

func (team *Team) BeforeDelete(tx *gorm.DB) (err error) {
   log.Println("------- delete team ---------")
   tx.Where("team_id = ?", team.ID).Delete(&Customer{})
   return
}

func (customer *Customer) BeforeDelete(tx *gorm.DB) (err error) {
   log.Println("------- delete customer ---------")
   tx.Where("owner_type = ? AND owner_id = ?", "customers", customer.ID).Delete(&Note{})
    return
}

func (note *Note) BeforeDelete(tx *gorm.DB) (err error) {
   log.Println("------- delete note ---------")
   return
}

func init() {
   var err error
   DB, err = gorm.Open("sqlite3", "data.DB")

   if err != nil {
      log.Printf("Error from gorm.Open: %s\n", err)
   }

   log.Println("You connected to your database.")

   if DB.HasTable(&Team{}) {
      DB.DropTable(&Team{})
      DB.DropTable(&Customer{})
      DB.DropTable(&Note{})
   }

   if !DB.HasTable(&Team{}) {
      DB.CreateTable(&Team{})
   }
   if !DB.HasTable(&Customer{}) {
      DB.CreateTable(&Customer{})
   }
   if !DB.HasTable(&Note{}) {
      DB.CreateTable(&Note{})
   }
}

func createTeam(name string) Team {
   team := Team{Name: name}
   DB.Create(&team)
   return team
}

func addCustomer(teamID uint, name string) Customer {
    customer1 := Customer{Name: name}
    customer1.TeamID = teamID
    customer1.Notes = []Note{}
    DB.Create(&customer1)
    return customer1
}

  func addNoteToCustomer(customerID uint, note Note) (customer Customer, err error) {
  if DB.Preload("Notes").First(&customer, customerID).RecordNotFound()   {
     return customer, errors.New("customer doesn't exists")
  }

   customer.Notes = append(customer.Notes, note)
   DB.Save(&customer)
   return customer, err
}

func main() {
   team := createTeam("Team 1")
   team2 := createTeam("Team 2")
   // Create customers

   customer1 := addCustomer(team.ID, "TestC 1")
   customer2 := addCustomer(team.ID, "TestC 2")
   customer3 := addCustomer(team2.ID, "TestC 3")
   customer4 := addCustomer(team2.ID, "TestC 4")

   note1 := Note{Content: "testcontent"}
   addNoteToCustomer(customer1.ID, note1)
   note2 := Note{Content: "testcontent 2"}
   addNoteToCustomer(customer2.ID, note2)
   note3 := Note{Content: "testcontent 3"}
   addNoteToCustomer(customer3.ID, note3)
   note4 := Note{Content: "testcontent 4"}
   addNoteToCustomer(customer4.ID, note4)

   DB.Delete(&team)
}

最佳答案

我认为这是因为将 BeforeDelete 函数添加到 Customer 模型结构的指针。

您只是在第一个示例中传入 Customer{}，它不是指向模型结构的指针。试试下面的例子？

var customer Customer
func (team *Team) BeforeDelete(tx *gorm.DB) (err error) {
    tx.Where("team_id = ?", team.ID).Delete(&customer)
    return
}

关于如果在其他回调中启动删除，则不会调用 Go-gorm BeforeDelete 回调，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/46238692/