GORM (3) - Associations

Belongs To

---

Belongs To

belongs to 관계는 다른 모델과의 1대1 연결을 설정해줍니다. 

type User struct {
  gorm.Model
  Name string
}

// `Profile` belongs to `User`, `UserID` is the foreign key
type Profile struct {
  gorm.Model
  UserID int
  User   User
  Name   string
}

Foreign Key

belongs to 관계를 정의하기 위해서는 foreign key가 무조건 존재해야 합니다. 기본 값으로는 owner의 type 명과 pk의 결합이 사용된다. GORM은 foreign key를 커스터마이즈할 수 있도록 합니다.

type User struct {
  gorm.Model
  Name string
}

type Profile struct {
  gorm.Model
  Name      string
  User      User `gorm:"foreignkey:UserRefer"` // use UserRefer as foreign key
  UserRefer uint
}

Association Foreign Key

belongs to에서 GROM는 대게 owner의 pk를 foreign key의 값으로 사용합니다. 맨 위의 코드를 예를 들면, GORM에서는 userID를 profile의 UserID에 저장합니다. 이것을 association_foreignkey로 바꿀 수 있습니다.

type User struct {
  gorm.Model
  Refer string
  Name string
}

type Profile struct {
  gorm.Model
  Name      string
  User      User `gorm:"association_foreignkey:Refer"` // use Refer as association foreign key
  UserRefer string
}

아래와 같이 belongs to 관계를 사용할 수 있습니다.

db.Model(&user).Related(&profile)
//// SELECT * FROM profiles WHERE user_id = 111; // 111 is user's ID

 

Has One

---

Has One

has one 또한 1대1 연결을 설정해주지만 다소 상이한 시멘틱을 가지고 있습니다. 이 association은 하나의 모델의 객체가 하나의 다른 모델을 포함하고 있다는 걸 나타냅니다. 예를 들어 user와 creditcard 모델이 있을 때, 각각의 user는 단 하나의 creditcard 만을 가집니다.

// User has one CreditCard, CreditCardID is the foreign key
type CreditCard struct {
  gorm.Model
  Number   string
  UserID   uint
}

type User struct {
  gorm.Model
  CreditCard   CreditCard
}

Foreign Key

has one 관계에서도 foreign key는 필요합니다. owned가 owner의 pk를 fk로 저장합니다. field명은 모델의 type과 pk의 결합으로 만들어집니다. 위의 UserID가 예시입니다. user가 creditcard를 소유하게 되면 user의 ID를 userID로 저장합니다. 물론 아래와 같이 커스터마이즈 할수 있습니다.

type CreditCard struct {
  gorm.Model
  Number string
  UID    string
}

type User struct {
  gorm.Model
  Name       `sql:"index"`
  CreditCard CreditCard `gorm:"foreignkey:uid;association_foreignkey:name"`
}

Polymorphism Association

다형성 has many, has one 을 지원합니다.

type Cat struct {
  ID    int
  Name  string
  Toy   Toy `gorm:"polymorphic:Owner;"`
}

type Dog struct {
  ID   int
  Name string
  Toy  Toy `gorm:"polymorphic:Owner;"`
}

type Toy struct {
  ID        int
  Name      string
  OwnerID   int
  OwnerType string
}

아래와 같이 has one을 사용합니다.

var card CreditCard
db.Model(&user).Related(&card, "CreditCard")
//// SELECT * FROM credit_cards WHERE user_id = 123; // 123 is user's primary key
// CreditCard is user's field name, it means get user's CreditCard relations and fill it into variable card
// If the field name is same as the variable's type name, like above example, it could be omitted, like:
db.Model(&user).Related(&card)

 

Has Many

---

Has Many

has many는 1대다 연결을 설정해줍니다. owner는 0개 이상의 모델의 객체를 소유할 수 있습니다. 

// User has many CreditCards, UserID is the foreign key
type User struct {
  gorm.Model
  CreditCards []CreditCard
}

type CreditCard struct {
  gorm.Model
  Number   string
  UserID  uint
}

Foreign key & Association Foreign Key

foreign key는 has one과 같이 owner type과 pk의 결합이며 커스터마이즈가 가능합니다. 

type User struct {
  gorm.Model
  CreditCards []CreditCard `gorm:"foreignkey:UserRefer"`
}

type CreditCard struct {
  gorm.Model
  Number    string
  UserRefer uint
}

type User struct {
  gorm.Model
  MemberNumber string
  CreditCards  []CreditCard `gorm:"foreignkey:UserMemberNumber;association_foreignkey:MemberNumber"`
}

type CreditCard struct {
  gorm.Model
  Number           string
  UserMemberNumber string
}

아래와 같이 has many를 사용합니다.

db.Model(&user).Related(&emails)
//// SELECT * FROM emails WHERE user_id = 111; // 111 is user's primary key

 

Many To Many

---

Many To Many

many to many는 두 모델 사이의 join table 입니다. 예를 들어, user와 language 모델이 있다고 할 때, user는 다양한 language를 말할 수 있고 많은 유저가 특정 언어를 말할 수 있습니다.

// User has and belongs to many languages, use `user_languages` as join table
type User struct {
  gorm.Model
  Languages         []Language `gorm:"many2many:user_languages;"`
}

type Language struct {
  gorm.Model
  Name string
}

 

Back-Reference 

양방향으로 참조가 가능한 구조입니다.

// User has and belongs to many languages, use `user_languages` as join table
type User struct {
  gorm.Model
  Languages         []*Language `gorm:"many2many:user_languages;"`
}

type Language struct {
  gorm.Model
  Name string
  Users         	  []*User     `gorm:"many2many:user_languages;"`
}

var users []User
language := Language{}

db.First(&language, "id = ?", 111)

db.Model(&language).Related(&users,  "Users")
//// SELECT * FROM "users" INNER JOIN "user_languages" ON "user_languages"."user_id" = "users"."id" WHERE  ("user_languages"."language_id" IN ('111'))

Foreign Keys

many2many에서 두 모델의 관계는 join table에 저장이 됩니다. 이 때, table 명과 fk를 커스텀할 수 있습니다.

type CustomizePerson struct {
  IdPerson string             `gorm:"primary_key:true"`
  Accounts []CustomizeAccount `gorm:"many2many:PersonAccount;association_foreignkey:idAccount;foreignkey:idPerson"`
}

type CustomizeAccount struct {
  IdAccount string `gorm:"primary_key:true"`
  Name      string
}

Join Table Foreign Key

join table의 fk 명을 변경할 수 있습니다.

type CustomizePerson struct {
  IdPerson string             `gorm:"primary_key:true"`
  Accounts []CustomizeAccount `gorm:"many2many:PersonAccount;foreignkey:idPerson;association_foreignkey:idAccount;association_jointable_foreignkey:account_id;jointable_foreignkey:person_id;"`
}

type CustomizeAccount struct {
  IdAccount string `gorm:"primary_key:true"`
  Name      string
}

Self-Referencing

self referencing을 위해서는 join table에서 association의 fk를 변경해줘야합니다. struct 명과 pk의 결합을 다음과 같이 바꿀 수 있습니다.

그렇다면 GORM은 join table을 user_id와 friend_id 라는 fk를 생성하여 self-reference를 할 수 있습니다.

type User struct {
  gorm.Model
  Friends []*User `gorm:"many2many:friendships;association_jointable_foreignkey:friend_id"`
}

DB.Preload("Friends").First(&user, "id = ?", 1)

DB.Model(&user).Association("Friends").Append(&User{Name: "friend1"}, &User{Name: "friend2"})

DB.Model(&user).Association("Friends").Delete(&User{Name: "friend2"})

DB.Model(&user).Association("Friends").Replace(&User{Name: "new friend"})

DB.Model(&user).Association("Friends").Clear()

DB.Model(&user).Association("Friends").Count()

아래와 같이 many2many를 사용합니다.

db.Model(&user).Related(&languages, "Languages")
//// SELECT * FROM "languages" INNER JOIN "user_languages" ON "user_languages"."language_id" = "languages"."id" WHERE "user_languages"."user_id" = 111

// Preload Languages when query user
db.Preload("Languages").First(&user)

 

Associations

---

Auto Create/Update

GORM은 자동으로 association과 reference를 저장합니다. 만약 association이 pk를 가졌다면 GORM은 저장을 위해 update를 합니다.

user := User{
  Name:            "jinzhu",
  BillingAddress:  Address{Address1: "Billing Address - Address 1"},
  ShippingAddress: Address{Address1: "Shipping Address - Address 1"},
  Emails:          []Email{
    {Email: "jinzhu@example.com"},
    {Email: "jinzhu-2@example.com"},
  },
  Languages:       []Language{
    {Name: "ZH"},
    {Name: "EN"},
  },
}

db.Create(&user)
//// BEGIN TRANSACTION;
//// INSERT INTO "addresses" (address1) VALUES ("Billing Address - Address 1");
//// INSERT INTO "addresses" (address1) VALUES ("Shipping Address - Address 1");
//// INSERT INTO "users" (name,billing_address_id,shipping_address_id) VALUES ("jinzhu", 1, 2);
//// INSERT INTO "emails" (user_id,email) VALUES (111, "jinzhu@example.com");
//// INSERT INTO "emails" (user_id,email) VALUES (111, "jinzhu-2@example.com");
//// INSERT INTO "languages" ("name") VALUES ('ZH');
//// INSERT INTO user_languages ("user_id","language_id") VALUES (111, 1);
//// INSERT INTO "languages" ("name") VALUES ('EN');
//// INSERT INTO user_languages ("user_id","language_id") VALUES (111, 2);
//// COMMIT;

db.Save(&user)

Skip AutoUpdate/AutoCreate

만약 association이 이미 데이터베이스에 존재한다면 update를 원치 않을 것입니다. 그렇다면 DB 세팅을 통하거나 Gorm 태그를 통해 생략할 수 있습니다. 그리고 autoupdate를 중지하더라도 association w/o pk는 여전히 생성되고 reference가 저장될 것입니다. 이 또한 생략할 수 있습니다. 또한 둘다 한번에 생략할 수 있습니다.

// Don't update associations having primary key, but will save reference
db.Set("gorm:association_autoupdate", false).Create(&user)
db.Set("gorm:association_autoupdate", false).Save(&user)

type User struct {
  gorm.Model
  Name       string
  CompanyID  uint
  // Don't update associations having primary key, but will save reference
  Company    Company `gorm:"association_autoupdate:false"`
}

// ------------------------------------------------

// Don't create associations w/o primary key, WON'T save its reference
db.Set("gorm:association_autocreate", false).Create(&user)
db.Set("gorm:association_autocreate", false).Save(&user)

type User struct {
  gorm.Model
  Name       string
  // Don't create associations w/o primary key, WON'T save its reference
  Company1   Company `gorm:"association_autocreate:false"`
}

// ------------------------------------------------

db.Set("gorm:association_autoupdate", false).Set("gorm:association_autocreate", false).Create(&user)

type User struct {
  gorm.Model
  Name    string
  Company Company `gorm:"association_autoupdate:false;association_autocreate:false"`
}

db.Set("gorm:save_associations", false).Create(&user)
db.Set("gorm:save_associations", false).Save(&user)

type User struct {
  gorm.Model
  Name    string
  Company Company `gorm:"save_associations:false"`
}

Skip Save Reference

만약 association의 reference 조차 저장하고 싶지 않다면 다음고 같이 할 수 있습니다.

db.Set("gorm:association_save_reference", false).Save(&user)
db.Set("gorm:association_save_reference", false).Create(&user)

type User struct {
  gorm.Model
  Name       string
  CompanyID  uint
  Company    Company `gorm:"association_save_reference:false"`
}

Association Mode

GORM은 association을 위한 다양한 모드를 제공합니다.

// Start Association Mode
var user User
db.Model(&user).Association("Languages")
// `user` is the source, must contains primary key
// `Languages` is source's field name for a relationship
// AssociationMode can only works if above two conditions both matched, check it ok or not:
// db.Model(&user).Association("Languages").Error


// 매칭되는 association을 찾습니다.
db.Model(&user).Association("Languages").Find(&languages)

// 새로운 association을 쌓습니다. many2many, has many 그리고 has one, belongs to 와 같은 association은 변경될 수 있습니다.
db.Model(&user).Association("Languages").Append([]Language{languageZH, languageEN})
db.Model(&user).Association("Languages").Append(Language{Name: "DE"})
db.Model(&user).Association("Languages").Replace([]Language{languageZH, languageEN})
db.Model(&user).Association("Languages").Replace(Language{Name: "DE"}, languageEN)

// 관계를 삭제 할 수 있습니다. DB에서 관계만 삭제됩니다.

db.Model(&user).Association("Languages").Delete([]Language{languageZH, languageEN})
db.Model(&user).Association("Languages").Delete(languageZH, languageEN)

// 한번에 초기화도 가능합니다. 
db.Model(&user).Association("Languages").Clear()

// 현재 association의 개수를 얻을 수 있습니다.
db.Model(&user).Association("Languages").Count()

 

Preload

---

Preloading

// the struct User and Order for below code
type User struct {
  gorm.Model
  Username string
  Orders Order
}
type Order struct {
  gorm.Model
  UserID uint
  Price float64
}
// the Preload function's param should be the main struct's field name
db.Preload("Orders").Find(&users)
//// SELECT * FROM users;
//// SELECT * FROM orders WHERE user_id IN (1,2,3,4);

db.Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)
//// SELECT * FROM users;
//// SELECT * FROM orders WHERE user_id IN (1,2,3,4) AND state NOT IN ('cancelled');

db.Where("state = ?", "active").Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)
//// SELECT * FROM users WHERE state = 'active';
//// SELECT * FROM orders WHERE user_id IN (1,2) AND state NOT IN ('cancelled');

db.Preload("Orders").Preload("Profile").Preload("Role").Find(&users)
//// SELECT * FROM users;
//// SELECT * FROM orders WHERE user_id IN (1,2,3,4); // has many
//// SELECT * FROM profiles WHERE user_id IN (1,2,3,4); // has one
//// SELECT * FROM roles WHERE id IN (4,5,6); // belongs to

Auto/Nested/Custom Preloading

type User struct {
  gorm.Model
  Name       string
  CompanyID  uint
  Company    Company `gorm:"PRELOAD:false"` // not preloaded
  Role       Role                           // preloaded
}

db.Set("gorm:auto_preload", true).Find(&users)

db.Preload("Orders.OrderItems").Find(&users)
db.Preload("Orders", "state = ?", "paid").Preload("Orders.OrderItems").Find(&users)

db.Preload("Orders", func(db *gorm.DB) *gorm.DB {
  return db.Order("orders.amount DESC")
}).Find(&users)
//// SELECT * FROM users;
//// SELECT * FROM orders WHERE user_id IN (1,2,3,4) order by orders.amount DESC;