GORM 소개
GORM은 Go 언어를 위한 오픈 소스 ORM(Object-Relational Mapping) 라이브러리입니다. ORM은 객체 지향 프로그래밍 언어를 사용하여 데이터베이스를 조작할 수 있도록 돕는 기술로, Go 구조체를 데이터베이스 테이블에 매핑하여 SQL 쿼리를 직접 작성하는 대신 Go 코드로 데이터베이스 작업을 수행하게 해줍니다.
핵심 개념
- 구조체와 테이블 매핑: Go의 구조체는 데이터베이스의 테이블과 매핑됩니다.
- 구조체 인스턴스와 데이터 행: 구조체 인스턴스 하나는 테이블의 하나의 데이터 행에 해당합니다.
- 구조체 필드와 열: 구조체 필드는 테이블의 열에 해당합니다.
장단점
GORM과 같은 ORM을 사용하면 개발 효율성을 크게 높일 수 있지만, 몇 가지 트레이드오프가 존재합니다.
- 장점:
- 개발 속도 향상: SQL 쿼리 작성 시간을 줄여 빠르게 애플리케이션을 개발할 수 있습니다.
- 코드 일관성 유지: 데이터베이스 로직을 Go 코드 내에서 관리하여 일관된 개발 패턴을 유지할 수 있습니다.
- 데이터베이스 독립성: 데이터베이스 종류를 변경할 때 코드 수정이 적습니다.
- 단점:
- 성능 저하 가능성: 복잡한 쿼리의 경우, ORM이 생성하는 SQL이 수동으로 작성한 쿼리보다 효율적이지 않을 수 있습니다.
- 유연성 감소: ORM이 지원하지 않는 특정 데이터베이스 기능이나 복잡한 쿼리에는 제한이 있을 수 있습니다.
- SQL 능력 약화: ORM에 의존하다 보면 개발자의 SQL 이해도가 저하될 수 있습니다.
환경 설정
GORM 및 드라이버 설치
GORM을 사용하려면 먼저 라이브러리와 사용하는 데이터베이스에 맞는 드라이버를 설치해야 합니다.
go get -u gorm.io/gorm
go get -u gorm.io/driver/sqlite // SQLite 드라이버 예시
go get -u gorm.io/driver/mysql // MySQL 드라이버 예시
데이터베이스 연결
GORM을 사용하여 데이터베이스에 연결하는 예시입니다. 여기서는 MySQL을 사용합니다.
package main
import (
"fmt"
"log"
"gorm.io/driver/mysql"
"gorm.io/gorm"
)
func main() {
// MySQL DSN(Data Source Name)
// 사용자명:비밀번호@tcp(호스트:포트)/데이터베이스명?파라미터
dsn := "user:password@tcp(127.0.0.1:3306)/database_name?charset=utf8mb4&parseTime=True&loc=Local"
db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
if err != nil {
log.Fatalf("데이터베이스 연결 실패: %v", err)
}
fmt.Println("데이터베이스에 성공적으로 연결되었습니다!")
// 이후 데이터베이스 작업 수행
}
GORM 모델 정의
구조체 모델
GORM에서 데이터베이스 테이블은 Go 구조체로 표현됩니다. 다음은 사용자 정보를 담는 Person 구조체 예시입니다.
type Person struct {
ID uint // 기본 키, GORM이 자동으로 관리
Name string // 일반 문자열 필드
Email *string // 문자열 포인터, NULL 값 허용
Age uint8 // 부호 없는 8비트 정수
Birthday *time.Time // time.Time 포인터, NULL 값 허용
MemberCode sql.NullString // sql.NullString, NULL 가능 문자열을 더 명확하게 처리
ActivatedTime sql.NullTime // sql.NullTime, NULL 가능 시간 필드를 명확하게 처리
CreatedAt time.Time // GORM이 생성 시 자동으로 채움
UpdatedAt time.Time // GORM이 업데이트 시 자동으로 채움
ignoredField string // 소문자로 시작하는 필드는 GORM에 의해 무시됨 (비공개 필드)
}
uint,string,uint8등은 직접적인 숫자/문자열 타입입니다.*string,*time.Time과 같은 포인터 타입은 데이터베이스에서 NULL 값을 허용하는 필드에 사용됩니다.database/sql패키지의sql.NullString,sql.NullTime등은 NULL 값을 보다 명시적으로 다룰 때 유용합니다.CreatedAt과UpdatedAt은 GORM이 레코드 생성 및 업데이트 시 현재 시간을 자동으로 채워주는 특별한 필드입니다.
GORM 관례
GORM은 데이터베이스 테이블 및 컬럼 이름에 대한 특정 관례를 따릅니다. 이러한 관례는 태그를 통해 재정의할 수 있습니다.
기본 키 (Primary Key)
- GORM은 기본적으로
ID라는 필드를 모델의 기본 키로 사용합니다. - 다른 필드를 기본 키로 사용하려면 구조체 태그
gorm:"primaryKey"를 사용합니다.
type Animal struct {
AnimalID int64 `gorm:"primaryKey"` // AnimalID를 기본 키로 설정
Name string
Age int64
}
테이블 이름
- 기본적으로 GORM은 구조체 이름의 복수형을 테이블 이름으로 사용합니다 (예:
Person구조체 ->people테이블). - 이러한 자동 복수형 변환을 비활성화하려면
db.NamingStrategy.SingularTable = true를 설정합니다.
package main
import (
"fmt"
"log"
"gorm.io/driver/mysql"
"gorm.io/gorm"
"gorm.io/gorm/schema" // NamingStrategy를 위해 임포트
)
type User struct { // 'users' 테이블로 매핑될 구조체
ID uint
Name string
}
func main() {
dsn := "user:password@tcp(127.0.0.1:3306)/database_name?charset=utf8mb4&parseTime=True&loc=Local"
db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
NamingStrategy: schema.NamingStrategy{
SingularTable: true, // 복수형 테이블 이름 사용 비활성화 (User -> user 테이블)
},
})
if err != nil {
log.Fatalf("데이터베이스 연결 실패: %v", err)
}
// AutoMigrate를 통해 'user' 테이블 생성 시도
db.AutoMigrate(&User{})
fmt.Println("데이터베이스에 성공적으로 연결되었으며 테이블 마이그레이션을 시도했습니다!")
}
컬럼 이름
- 컬럼 이름은 필드 이름을 스네이크 케이스(snake_case)로 변환하여 생성합니다 (예:
CreatedAt->created_at).
타임스탬프 필드
CreatedAt: 레코드 생성 시 자동으로 현재 시간을 채웁니다.db.Create(&person) // `CreatedAt`은 현재 시간으로 설정 db.Model(&person).Update("CreatedAt", time.Now()) // Update 메서드로 값 변경 가능UpdatedAt: 레코드 업데이트 시 자동으로 현재 시간을 채웁니다.db.Save(&person) // `UpdatedAt`은 현재 시간으로 설정 db.Model(&person).Update("name", "Jane Doe") // `UpdatedAt`이 현재 시간으로 업데이트DeletedAt: GORM의 소프트 딜리트(Soft Delete) 기능과 함께 사용되며, 레코드 삭제 시 삭제 시간을 기록하고 실제 삭제는 하지 않습니다. (gorm.Model에 포함)
사전 정의된 GORM 모델
GORM은 일반적으로 많이 사용되는 필드를 포함하는 gorm.Model 구조체를 제공합니다. 이를 모델에 임베딩하여 편리하게 사용할 수 있습니다.
// gorm.Model의 정의
type Model struct {
ID uint `gorm:"primaryKey"`
CreatedAt time.Time
UpdatedAt time.Time
DeletedAt gorm.DeletedAt `gorm:"index"` // 소프트 삭제를 위한 필드
}
고급 옵션: 임베디드 구조체
Go의 임베디드 필드 기능을 활용하여 다른 구조체를 현재 구조체에 포함시킬 수 있습니다. GORM은 이를 테이블의 컬럼으로 확장합니다.
- 익명 필드 임베딩:
type AuthorInfo struct { Name string Email string } type Article struct { AuthorInfo // 익명 필드로 임베딩 ID int Views int32 } // 위 Article 구조체는 다음과 같이 확장됩니다: type Article struct { ID int Name string Email string Views int32 } - 이름 있는 필드 임베딩:
gorm:"embedded"태그를 사용하여 명시적으로 임베딩할 수 있습니다.type AuthorDetails struct { Name string Email string } type Post struct { ID int Author AuthorDetails `gorm:"embedded"` // embedded 태그 사용 Likes int32 } // 위 Post 구조체는 다음과 같이 확장됩니다: type Post struct { ID int Name string Email string Likes int32 } - 임베디드 필드에 접두사 추가:
gorm:"embeddedPrefix:접두사_"태그를 사용하여 임베디드 필드의 컬럼 이름에 접두사를 붙일 수 있습니다.type PublisherInfo struct { Name string Contact string } type Book struct { ID int Publisher PublisherInfo `gorm:"embedded;embeddedPrefix:publisher_"` // publisher_ 접두사 추가 Copies int32 } // 위 Book 구조체는 다음과 같이 확장됩니다: type Book struct { ID int PublisherName string PublisherContact string Copies int32 }
필드 태그 목록
GORM은 구조체 필드에 다양한 태그를 사용하여 데이터베이스 컬럼의 속성을 제어할 수 있습니다. 다음은 주요 태그 목록입니다.
| 태그명 | 설명 |
|---|---|
column |
데이터베이스 컬럼 이름 지정 |
type |
컬럼 데이터 타입 지정 (예: type:varchar(256), type:MEDIUMINT UNSIGNED not NULL AUTO_INCREMENT) |
serializer |
데이터를 데이터베이스로 직렬화/역직렬화할 직렬 변환기 지정 (예: serializer:json) |
size |
컬럼 데이터 타입의 크기/길이 정의 (예: size:256) |
primaryKey |
기본 키로 지정 |
unique |
고유 제약 조건 추가 |
default |
컬럼의 기본값 정의 |
precision |
수치 컬럼의 정밀도 지정 |
scale |
수치 컬럼의 소수점 이하 자릿수 지정 |
not null |
NOT NULL 제약 조건 추가 |
autoIncrement |
자동 증가 컬럼으로 지정 |
autoIncrementIncrement |
자동 증가 스텝 크기 지정 |
embedded |
구조체 임베딩 |
embeddedPrefix |
임베디드 필드 컬럼 이름의 접두사 지정 |
autoCreateTime |
레코드 생성 시 현재 시간을 자동으로 추적 (int 필드의 경우 타임스탬프 초, nano/milli로 나노/밀리초 추적 가능) |
autoUpdateTime |
레코드 생성/업데이트 시 현재 시간을 자동으로 추적 (int 필드의 경우 타임스탬프 초, nano/milli로 나노/밀리초 추적 가능) |
index |
인덱스 생성 (동일 이름 사용 시 복합 인덱스) |
uniqueIndex |
고유 인덱스 생성 (index와 동일하나 고유 제약 조건 추가) |
check |
CHECK 제약 조건 생성 (예: check:age > 13) |
<- |
필드 쓰기 권한 설정 (<-:create 생성만, <-:update 업데이트만, <-:false 쓰기 금지, <- 생성 및 업데이트) |
-> |
필드 읽기 권한 설정 (->:false 읽기 금지) |
- |
필드 무시 (- 읽기/쓰기 무시, -:migration 마이그레이션 무시, -:all 전체 무시) |
comment |
마이그레이션 시 필드에 주석 추가 |
CRUD 작업
GORM은 데이터베이스의 Create, Read, Update, Delete (CRUD) 작업을 Go 메서드를 통해 간편하게 수행할 수 있도록 합니다.
데이터 생성 (Create)
Create 메서드: 새 레코드 생성
package main
import (
"fmt"
"log"
"time"
"gorm.io/driver/sqlite" // SQLite 예시
"gorm.io/gorm"
)
type Member struct {
gorm.Model
Name string
Email string `gorm:"unique"`
Age uint8
}
func main() {
db, err := gorm.Open(sqlite.Open("gorm.db"), &gorm.Config{})
if err != nil {
log.Fatalf("데이터베이스 연결 실패: %v", err)
}
db.AutoMigrate(&Member{}) // 테이블 자동 마이그레이션
// 단일 레코드 생성
newMember := Member{Name: "김철수", Email: "kim@example.com", Age: 30}
result := db.Create(&newMember)
if result.Error != nil {
log.Printf("멤버 생성 오류: %v", result.Error)
} else {
fmt.Printf("새 멤버 생성: ID=%d, Name=%s\n", newMember.ID, newMember.Name)
}
// 배치 삽입: 여러 레코드 한 번에 생성
membersToCreate := []Member{
{Name: "이영희", Email: "lee@example.com", Age: 25},
{Name: "박민수", Email: "park@example.com", Age: 35},
}
batchResult := db.Create(&membersToCreate)
if batchResult.Error != nil {
log.Printf("멤버 배치 생성 오류: %v", batchResult.Error)
} else {
fmt.Printf("%d명의 멤버가 배치로 생성되었습니다.\n", batchResult.RowsAffected)
}
}
FirstOrCreate 메서드: 조건에 맞는 레코드 검색 또는 생성
조건에 맞는 레코드가 존재하면 해당 레코드를 반환하고, 없으면 새로 생성합니다.
var user Member
db.FirstOrCreate(&user, Member{Name: "고길동", Email: "go@example.com"}) // 이름과 이메일로 검색, 없으면 생성
fmt.Printf("FirstOrCreate 결과: ID=%d, Name=%s, Email=%s\n", user.ID, user.Name, user.Email)
var existingUser Member
db.FirstOrCreate(&existingUser, Member{Email: "kim@example.com"}) // 이미 존재하는 이메일로 검색
fmt.Printf("FirstOrCreate (기존) 결과: ID=%d, Name=%s, Email=%s\n", existingUser.ID, existingUser.Name, existingUser.Email)
Save 메서드: 레코드 저장 (존재하지 않으면 생성, 존재하면 업데이트)
// 새 레코드 저장 (생성)
saveMember := Member{Name: "최영진", Email: "choi@example.com", Age: 28}
db.Save(&saveMember)
fmt.Printf("Save (생성) 결과: ID=%d, Name=%s\n", saveMember.ID, saveMember.Name)
// 기존 레코드 저장 (업데이트)
saveMember.Age = 29
db.Save(&saveMember)
fmt.Printf("Save (업데이트) 결과: ID=%d, Name=%s, Age=%d\n", saveMember.ID, saveMember.Name, saveMember.Age)
Omit 메서드: 특정 필드 무시 (생성 시)
Create 또는 Save 작업 시 특정 필드를 데이터베이스에 포함하지 않도록 지정합니다.
memberWithOmit := Member{Name: "한지민", Email: "han@example.com", Age: 40}
db.Omit("Age").Create(&memberWithOmit) // Age 필드는 데이터베이스에 저장되지 않음
fmt.Printf("Omit 적용 후 생성: ID=%d, Name=%s, Email=%s (Age 필드 무시)\n", memberWithOmit.ID, memberWithOmit.Name, memberWithOmit.Email)
Assign 메서드: 필드 값 할당 (데이터베이스에 저장하지는 않음)
FirstOrCreate와 함께 사용하여, 레코드가 새로 생성될 때만 특정 값을 할당할 수 있습니다.
var assignMember Member
// 이메일로 찾고, 없으면 Age를 20으로 설정하여 생성
db.Assign(Member{Age: 20}).FirstOrCreate(&assignMember, Member{Email: "unknown@example.com", Name: "미상"})
fmt.Printf("Assign과 FirstOrCreate 결과: ID=%d, Name=%s, Email=%s, Age=%d\n",
assignMember.ID, assignMember.Name, assignMember.Email, assignMember.Age)
// 이미 존재하는 레코드에 대해 Assign은 효과가 없음 (FirstOrCreate의 생성 조건에만 영향)
var existingAssignMember Member
db.Assign(Member{Age: 99}).FirstOrCreate(&existingAssignMember, Member{Email: "kim@example.com"})
fmt.Printf("Assign과 FirstOrCreate (기존) 결과: ID=%d, Name=%s, Email=%s, Age=%d (Age는 변경되지 않음)\n",
existingAssignMember.ID, existingAssignMember.Name, existingAssignMember.Email, existingAssignMember.Age)
데이터 조회 (Read)
기본 조회 메서드
// 모든 멤버 조회
var allMembers []Member
db.Find(&allMembers)
fmt.Println("--- 모든 멤버 ---")
for _, m := range allMembers {
fmt.Printf("ID: %d, Name: %s, Email: %s, Age: %d\n", m.ID, m.Name, m.Email, m.Age)
}
// 조건 없이 첫 번째 레코드 조회
var firstMember Member
db.First(&firstMember)
fmt.Printf("--- 첫 번째 멤버 --- ID: %d, Name: %s\n", firstMember.ID, firstMember.Name)
// 조건 없이 마지막 레코드 조회
var lastMember Member
db.Last(&lastMember)
fmt.Printf("--- 마지막 멤버 --- ID: %d, Name: %s\n", lastMember.ID, lastMember.Name)
// 임의의 한 레코드 조회
var randomMember Member
db.Take(&randomMember)
fmt.Printf("--- 임의의 멤버 --- ID: %d, Name: %s\n", randomMember.ID, randomMember.Name)
// 조건부 조회: Age가 30보다 큰 멤버
var adultMembers []Member
db.Where("age > ?", 30).Find(&adultMembers)
fmt.Println("--- 30세 초과 멤버 ---")
for _, m := range adultMembers {
fmt.Printf("ID: %d, Name: %s, Age: %d\n", m.ID, m.Name, m.Age)
}
// 다중 조건 조회: Age가 25보다 크고 이름에 "민수"가 포함된 멤버
var specificMembers []Member
db.Where("age > ? AND name LIKE ?", 25, "%민수%").Find(&specificMembers)
fmt.Println("--- 특정 조건 멤버 ---")
for _, m := range specificMembers {
fmt.Printf("ID: %d, Name: %s, Age: %d\n", m.ID, m.Name, m.Age)
}
// 특정 ID로 조회
var memberByID Member
db.First(&memberByID, 2) // ID가 2인 멤버 조회
fmt.Printf("--- ID 2번 멤버 --- Name: %s\n", memberByID.Name)
// 페이지네이션: 처음 2개 레코드 건너뛰고 다음 2개 레코드 조회
var paginatedMembers []Member
db.Offset(2).Limit(2).Find(&paginatedMembers)
fmt.Println("--- 페이지네이션 (Offset 2, Limit 2) ---")
for _, m := range paginatedMembers {
fmt.Printf("ID: %d, Name: %s\n", m.ID, m.Name)
}
// 특정 필드만 선택 조회 (Select)
var memberNames []string
db.Model(&Member{}).Select("name").Find(&memberNames)
fmt.Println("--- 모든 멤버 이름 (Select) ---")
fmt.Println(memberNames)
// 특정 필드만 추출 (Pluck)
var memberEmails []string
db.Model(&Member{}).Pluck("email", &memberEmails)
fmt.Println("--- 모든 멤버 이메일 (Pluck) ---")
fmt.Println(memberEmails)
고급 조회 메서드
// Where 메서드 체이닝
var chainedWhereMembers []Member
db.Where("age > ?", 20).Where("email LIKE ?", "%@example.com").Find(&chainedWhereMembers)
fmt.Println("--- Where 체이닝 멤버 ---")
for _, m := range chainedWhereMembers {
fmt.Printf("ID: %d, Name: %s, Age: %d\n", m.ID, m.Name, m.Age)
}
// Or 메서드: OR 조건
var orConditionMembers []Member
db.Where("age = ?", 25).Or("name = ?", "김철수").Find(&orConditionMembers)
fmt.Println("--- OR 조건 멤버 ---")
for _, m := range orConditionMembers {
fmt.Printf("ID: %d, Name: %s, Age: %d\n", m.ID, m.Name, m.Age)
}
// Not 메서드: NOT 조건
var notConditionMembers []Member
db.Not("age", 30).Find(¬ConditionMembers) // Age가 30이 아닌 멤버
fmt.Println("--- NOT 조건 멤버 (Age != 30) ---")
for _, m := range notConditionMembers {
fmt.Printf("ID: %d, Name: %s, Age: %d\n", m.ID, m.Name, m.Age)
}
// Order 메서드: 결과 정렬
var orderedMembers []Member
db.Order("age desc, name asc").Find(&orderedMembers) // Age 내림차순, Name 오름차순
fmt.Println("--- 정렬된 멤버 ---")
for _, m := range orderedMembers {
fmt.Printf("ID: %d, Name: %s, Age: %d\n", m.ID, m.Name, m.Age)
}
// Joins 메서드: 조인 쿼리 (예시를 위해 임시 구조체 사용, 실제 DB 스키마에 따라 달라짐)
// type UserProfile struct {
// UserID uint
// Bio string
// }
// db.AutoMigrate(&UserProfile{})
// db.Create(&UserProfile{UserID: 1, Bio: "GORM 사용자"})
// var joinedResults []struct {
// Member
// UserProfile
// }
// db.Model(&Member{}).Select("members.name, user_profiles.bio").Joins("JOIN user_profiles ON members.id = user_profiles.user_id").Find(&joinedResults)
// fmt.Println("--- 조인 쿼리 결과 ---")
// for _, r := range joinedResults {
// fmt.Printf("Name: %s, Bio: %s\n", r.Name, r.Bio)
// }
// Group 및 Having 메서드: 그룹화 및 그룹 조건
var ageCounts []map[string]interface{}
db.Model(&Member{}).Select("age, count(*) as count").Group("age").Having("count > ?", 1).Scan(&ageCounts)
fmt.Println("--- 연령별 멤버 수 (2명 이상) ---")
for _, ac := range ageCounts {
fmt.Printf("Age: %v, Count: %v\n", ac["age"], ac["count"])
}
구조체 및 맵을 이용한 쿼리
// 구조체로 조건 지정
var specificPerson Member
db.Where(&Member{Name: "김철수", Age: 30}).First(&specificPerson)
// SELECT * FROM members WHERE name = "김철수" AND age = 30 LIMIT 1;
fmt.Printf("구조체 조건 조회: ID=%d, Name=%s\n", specificPerson.ID, specificPerson.Name)
// 맵으로 조건 지정
var mapConditionPeople []Member
db.Where(map[string]interface{}{"name": "이영희", "age": 25}).Find(&mapConditionPeople)
// SELECT * FROM members WHERE name = "이영희" AND age = 25;
fmt.Println("맵 조건 조회 결과:")
for _, p := range mapConditionPeople {
fmt.Printf("ID: %d, Name: %s\n", p.ID, p.Name)
}
// 기본 키 슬라이스로 조건 지정
var idsToFind []uint = []uint{1, 3}
var selectedPeople []Member
db.Where(idsToFind).Find(&selectedPeople)
// SELECT * FROM members WHERE id IN (1, 3);
fmt.Println("ID 슬라이스 조건 조회 결과:")
for _, p := range selectedPeople {
fmt.Printf("ID: %d, Name: %s\n", p.ID, p.Name)
}
데이터 업데이트 (Update)
GORM은 다양한 방법으로 레코드를 업데이트할 수 있는 유연한 기능을 제공합니다.
// 업데이트할 멤버를 조회
var memberToUpdate Member
db.First(&memberToUpdate, 1) // ID가 1인 멤버 조회
fmt.Printf("업데이트 전: %s, %s\n", memberToUpdate.Name, memberToUpdate.Email)
// Save 메서드: 모든 필드를 업데이트 (구조체 필드 값에 따라)
memberToUpdate.Name = "김철수 (수정됨)"
memberToUpdate.Email = "chulsu_updated@example.com"
db.Save(&memberToUpdate) // `UpdatedAt` 자동 갱신
fmt.Printf("Save 후: %s, %s\n", memberToUpdate.Name, memberToUpdate.Email)
// Update 메서드: 단일 필드 업데이트
db.Model(&memberToUpdate).Update("Email", "new_chulsu@example.com") // `UpdatedAt` 자동 갱신
fmt.Printf("Update 후 (Email): %s\n", memberToUpdate.Email)
// Updates 메서드: 여러 필드 업데이트 (구조체 또는 맵 사용)
db.Model(&memberToUpdate).Updates(Member{Name: "새로운 김철수", Age: 31}) // `UpdatedAt` 자동 갱신
fmt.Printf("Updates (구조체) 후: %s, %d\n", memberToUpdate.Name, memberToUpdate.Age)
db.Model(&memberToUpdate).Updates(map[string]interface{}{"Name": "맵으로 변경", "Email": "map_update@example.com"})
fmt.Printf("Updates (맵) 후: %s, %s\n", memberToUpdate.Name, memberToUpdate.Email)
// UpdateColumn 메서드: 단일 필드 업데이트, 다른 필드 (예: UpdatedAt)는 무시
db.Model(&memberToUpdate).UpdateColumn("Email", "no_update_time@example.com") // `UpdatedAt` 변경 안 됨
fmt.Printf("UpdateColumn 후 (Email): %s\n", memberToUpdate.Email)
// UpdateColumns 메서드: 여러 필드 업데이트, 다른 필드는 무시
db.Model(&memberToUpdate).UpdateColumns(map[string]interface{}{"Name": "최종 이름", "Age": 40}) // `UpdatedAt` 변경 안 됨
fmt.Printf("UpdateColumns 후: %s, %d\n", memberToUpdate.Name, memberToUpdate.Age)
// Select 메서드와 함께 업데이트: 특정 필드만 업데이트
db.Model(&memberToUpdate).Select("Email").Updates(Member{Email: "only_email_updated@example.com", Name: "무시될 이름"})
fmt.Printf("Select 후 (Email): %s (Name은 변경 안됨)\n", memberToUpdate.Email)
// Omit 메서드와 함께 업데이트: 특정 필드를 제외하고 업데이트
db.Model(&memberToUpdate).Omit("Email").Updates(Member{Name: "이메일 제외 업데이트", Age: 33})
fmt.Printf("Omit 후 (Email 제외): %s, %s, %d\n", memberToUpdate.Name, memberToUpdate.Email, memberToUpdate.Age)
// Assign 메서드와 함께 업데이트: 필드 할당 후 저장 (Save와 결합)
// Assign은 먼저 모델에 값을 할당한 후 Save/Create와 같은 DB 작업이 이어질 때 사용됩니다.
var anotherMember Member
db.First(&anotherMember, 2)
db.Model(&anotherMember).Assign(Member{Age: 50}).Save(&anotherMember) // Age를 50으로 설정 후 저장
fmt.Printf("Assign & Save 후: ID=%d, Name=%s, Age=%d\n", anotherMember.ID, anotherMember.Name, anotherMember.Age)
데이터 삭제 (Delete)
GORM은 소프트 딜리트(Soft Delete)와 영구 삭제(Permanent Delete)를 지원합니다.
// 삭제할 멤버를 조회
var memberToDelete Member
db.First(&memberToDelete, 1) // ID가 1인 멤버 조회
// 단일 레코드 삭제 (소프트 딜리트)
db.Delete(&memberToDelete) // DeletedAt 필드가 채워지고 실제 데이터는 남아있음
fmt.Printf("ID %d 멤버 소프트 삭제됨.\n", memberToDelete.ID)
// 조건부 삭제 (소프트 딜리트): Age가 25 미만인 모든 멤버
db.Where("age < ?", 25).Delete(&Member{})
fmt.Printf("Age가 25 미만인 멤버들 소프트 삭제됨.\n")
// Unscoped 메서드: 영구 삭제 (소프트 딜리트된 레코드 포함)
var softDeletedMember Member
db.Unscoped().Where("id = ?", 1).First(&softDeletedMember) // 소프트 삭제된 레코드 조회
if softDeletedMember.ID != 0 {
db.Unscoped().Delete(&softDeletedMember) // 영구 삭제
fmt.Printf("ID %d 멤버 영구 삭제됨.\n", softDeletedMember.ID)
}
// 기본 키로 영구 삭제
db.Delete(&Member{}, 3) // ID가 3인 멤버 영구 삭제
fmt.Printf("ID 3번 멤버 영구 삭제됨.\n")
// Truncate 테이블: 테이블의 모든 레코드 삭제 (DANGER!)
// db.Exec("TRUNCATE TABLE members")
// fmt.Printf("members 테이블의 모든 레코드 삭제됨.\n")
데이터베이스 관계 (Associations)
GORM은 Go 구조체 간의 관계를 정의하고 이를 데이터베이스 외래 키(FOREIGN KEY) 제약 조건으로 매핑할 수 있습니다. FOREIGN KEY는 한 테이블의 키가 다른 테이블의 UNIQUE KEY(고유 제약 조건 키)를 가리키며, REFERENCES는 이 외래 키가 참조하는 다른 테이블의 필드를 지정합니다.
다대일 (Many-to-One)
예시: User는 하나의 Company에 속한다. CompanyID가 외래 키 역할을 합니다.
기본적인 다대일 관계
// User는 Company에 속하며, CompanyID가 외래 키입니다.
type User struct {
gorm.Model
Name string
CompanyID uint // Company 구조체의 기본 키(ID)를 참조하는 외래 키
Company Company // Company 구조체 (관계 정의)
}
type Company struct {
ID uint
Name string
}
// User 구조체의 CompanyID 필드는 암묵적으로 User와 Company 간의 외래 키 관계를 생성합니다.
// Company 내부 구조체를 채우려면 CompanyID 필드가 User 구조체에 포함되어야 합니다.
외래 키 재정의
gorm:"foreignKey:컬럼명" 태그를 사용하여 외래 키로 사용할 컬럼을 명시적으로 지정할 수 있습니다.
type Employee struct {
gorm.Model
FullName string
DeptCode string // 외래 키로 사용할 컬럼
Department Department `gorm:"foreignKey:DeptCode"` // DeptCode를 외래 키로 지정
}
type Department struct {
Code string `gorm:"primaryKey"` // Department의 기본 키는 Code
Name string
}
// Employee의 DeptCode는 Department의 Code를 참조합니다.
참조 키 재정의
gorm:"references:컬럼명" 태그를 사용하여 외래 키가 참조할 다른 테이블의 컬럼을 명시적으로 지정할 수 있습니다.
type Project struct {
gorm.Model
Title string
ManagerUUID string // 외래 키
Manager Personel `gorm:"references:EmployeeUUID"` // Personel의 EmployeeUUID를 참조
}
type Personel struct {
ID uint
EmployeeUUID string `gorm:"unique"` // Personel의 고유 식별자
Name string
}
// Project의 ManagerUUID는 Personel의 EmployeeUUID를 참조합니다.
일대일 (One-to-One)
예시: Account는 하나의 Profile을 가진다. AccountID가 외래 키 역할을 합니다.
// Account는 하나의 Profile을 가집니다. Profile의 AccountID가 외래 키입니다.
type Account struct {
gorm.Model
UserName string
UserProfile UserProfile // Profile 구조체 (관계 정의)
}
type UserProfile struct {
gorm.Model
Bio string
AccountID uint // Account의 ID를 참조하는 외래 키
}
// 필요에 따라 foreignKey 및 references 태그를 사용하여 관계를 명시적으로 설정할 수 있습니다.
일대다 (One-to-Many)
예시: Category는 여러 Product를 가질 수 있다. CategoryID가 외래 키 역할을 합니다.
// Category는 여러 Product를 가집니다. Product의 CategoryID가 외래 키입니다.
type Category struct {
gorm.Model
Name string
Products []Product // Products 슬라이스 (관계 정의)
}
type Product struct {
gorm.Model
Name string
Price float64
CategoryID uint // Category의 ID를 참조하는 외래 키
}
다대다 (Many-to-Many)
예시: Student는 여러 Course를 수강할 수 있고, Course는 여러 Student를 가질 수 있다. student_courses라는 조인 테이블이 사용됩니다.
// Student는 여러 Course를 수강할 수 있으며, `student_courses`가 조인 테이블입니다.
type Student struct {
gorm.Model
Name string
Courses []Course `gorm:"many2many:student_courses;"` // many2many 태그로 조인 테이블 지정
}
type Course struct {
gorm.Model
Title string
}
트랜잭션 (Transactions)
GORM은 데이터베이스 트랜잭션을 지원하여 여러 데이터베이스 작업이 하나의 논리적 단위로 처리되도록 보장합니다. GORM은 실제 트랜잭션 로직을 직접 구현하는 대신, 데이터베이스에 BEGIN, COMMIT, ROLLBACK 등의 SQL 명령을 보내 트랜잭션을 관리합니다.
수동 트랜잭션 (Manual Transactions)
수동 트랜잭션은 개발자가 db.Begin()으로 트랜잭션을 시작하고, tx.Commit() 또는 tx.Rollback()을 명시적으로 호출하여 트랜잭션의 생명 주기를 제어합니다. 복잡한 비즈니스 로직이나 조건부 커밋/롤백에 적합합니다.
기본 절차
- 트랜잭션 시작:
db.Begin()을 호출하여 트랜잭션 객체(tx *gorm.DB)를 얻습니다. - 트랜잭션 내 작업 실행:
tx객체를 통해 데이터베이스 작업을 수행합니다 (Create,Update,Delete등). - 결과 판단 및 종료: 모든 작업이 성공하면
tx.Commit()을 호출하고, 실패하면tx.Rollback()을 호출하여 변경 사항을 되돌립니다.
예시: 잔액 이체
package main
import (
"fmt"
"log"
"gorm.io/driver/sqlite"
"gorm.io/gorm"
)
// Account 모델 정의
type Account struct {
gorm.Model
Holder string
Balance int
}
// 수동 트랜잭션으로 잔액 이체 함수
func transferManual(db *gorm.DB, fromID, toID, amount int) error {
// 1. 트랜잭션 시작
tx := db.Begin()
if tx.Error != nil {
return fmt.Errorf("트랜잭션 시작 실패: %w", tx.Error)
}
// 트랜잭션이 어떤 이유로든 완료되지 않으면 롤백하도록 defer 설정
defer func() {
if r := recover(); r != nil {
tx.Rollback()
panic(r) // 패닉 다시 발생
} else if tx.Error != nil {
tx.Rollback() // 명시적인 에러가 있으면 롤백 (Commit/Rollback이 호출되지 않았을 때)
}
}()
// 2. 트랜잭션 내 작업 실행
var sender, receiver Account
// 보내는 계좌 조회
if err := tx.First(&sender, fromID).Error; err != nil {
tx.Rollback() // 오류 발생 시 롤백
return fmt.Errorf("보내는 계좌 조회 실패: %w", err)
}
// 받는 계좌 조회
if err := tx.First(&receiver, toID).Error; err != nil {
tx.Rollback() // 오류 발생 시 롤백
return fmt.Errorf("받는 계좌 조회 실패: %w", err)
}
// 잔액 부족 확인
if sender.Balance < amount {
tx.Rollback() // 잔액 부족 시 롤백
return fmt.Errorf("잔액 부족: %s님의 현재 잔액은 %d원", sender.Holder, sender.Balance)
}
// 보내는 계좌에서 금액 차감
if err := tx.Model(&sender).Update("balance", sender.Balance-amount).Error; err != nil {
tx.Rollback() // 오류 발생 시 롤백
return fmt.Errorf("송금 계좌 업데이트 실패: %w", err)
}
// 받는 계좌에 금액 추가
if err := tx.Model(&receiver).Update("balance", receiver.Balance+amount).Error; err != nil {
tx.Rollback() // 오류 발생 시 롤백
return fmt.Errorf("수금 계좌 업데이트 실패: %w", err)
}
// 3. 모든 작업 성공 시 커밋
return tx.Commit().Error
}
func main() {
db, err := gorm.Open(sqlite.Open("bank.db"), &gorm.Config{})
if err != nil {
log.Fatalf("데이터베이스 연결 실패: %v", err)
}
db.AutoMigrate(&Account{})
// 테스트 계좌 생성
db.Create(&Account{Holder: "홍길동", Balance: 1000}) // ID 1
db.Create(&Account{Holder: "임꺽정", Balance: 500}) // ID 2
fmt.Println("초기 잔액:")
var accounts []Account
db.Find(&accounts)
for _, acc := range accounts {
fmt.Printf("ID: %d, Holder: %s, Balance: %d\n", acc.ID, acc.Holder, acc.Balance)
}
// 잔액 이체 시도
fmt.Println("\n잔액 이체 시도 (홍길동 -> 임꺽정, 300원)...")
if err := transferManual(db, 1, 2, 300); err != nil {
fmt.Printf("이체 실패: %v\n", err)
} else {
fmt.Println("이체 성공!")
}
fmt.Println("\n이체 후 잔액:")
db.Find(&accounts)
for _, acc := range accounts {
fmt.Printf("ID: %d, Holder: %s, Balance: %d\n", acc.ID, acc.Holder, acc.Balance)
}
}
자동 트랜잭션 (Auto Transactions)
GORM의 db.Transaction() 메서드는 트랜잭션 로직을 함수로 캡슐화하여, 트랜잭션의 시작, 커밋, 롤백을 자동으로 처리해줍니다. 함수가 오류를 반환하면 GORM이 자동으로 롤백하고, nil을 반환하면 자동으로 커밋합니다. 이는 대부분의 트랜잭션 시나리오에서 코드를 간소화합니다.
// 자동 트랜잭션으로 잔액 이체 함수
func transferAuto(db *gorm.DB, fromID, toID, amount int) error {
// db.Transaction을 호출하고 트랜잭션 내 작업을 함수로 전달
return db.Transaction(func(tx *gorm.DB) error {
var sender, receiver Account
// 보내는 계좌 조회
if err := tx.First(&sender, fromID).Error; err != nil {
return fmt.Errorf("보내는 계좌 조회 실패: %w", err) // 오류 반환 시 Gorm 자동 롤백
}
// 받는 계좌 조회
if err := tx.First(&receiver, toID).Error; err != nil {
return fmt.Errorf("받는 계좌 조회 실패: %w", err)
}
// 잔액 부족 확인
if sender.Balance < amount {
return fmt.Errorf("잔액 부족: %s님의 현재 잔액은 %d원", sender.Holder, sender.Balance)
}
// 보내는 계좌에서 금액 차감
if err := tx.Model(&sender).Update("balance", sender.Balance-amount).Error; err != nil {
return fmt.Errorf("송금 계좌 업데이트 실패: %w", err)
}
// 받는 계좌에 금액 추가
if err := tx.Model(&receiver).Update("balance", receiver.Balance+amount).Error; err != nil {
return fmt.Errorf("수금 계좌 업데이트 실패: %w", err)
}
return nil // 오류가 없으면 Gorm 자동 커밋
})
}
중첩 트랜잭션 (Nested Transactions)
GORM은 데이터베이스의 SAVEPOINT 기능을 활용하여 중첩 트랜잭션을 구현합니다. 이는 외부 트랜잭션 내에서 또 다른 트랜잭션을 시작할 수 있게 해주며, 내부("자식") 트랜잭션이 롤백되어도 외부("부모") 트랜잭션에는 영향을 주지 않고 자식 트랜잭션의 변경 사항만 되돌릴 수 있습니다. 최종 커밋은 가장 바깥쪽 트랜잭션이 성공적으로 완료될 때만 발생합니다.
// 중첩 트랜잭션 예시 함수
func nestedTransaction(db *gorm.DB) error {
return db.Transaction(func(parentTx *gorm.DB) error {
// 부모 트랜잭션: 계좌 A 생성
accountA := Account{Holder: "김철수", Balance: 1000}
if err := parentTx.Create(&accountA).Error; err != nil {
return fmt.Errorf("계좌 A 생성 실패 (부모): %w", err) // 부모 트랜잭션 롤백
}
fmt.Printf("부모 트랜잭션: 계좌 A (%s, ID: %d) 생성됨\n", accountA.Holder, accountA.ID)
// 자식 트랜잭션 (중첩 트랜잭션) 시작
if err := parentTx.Transaction(func(childTx *gorm.DB) error {
// 자식 트랜잭션: 계좌 B 생성
accountB := Account{Holder: "이영희", Balance: 500}
if err := childTx.Create(&accountB).Error; err != nil {
return fmt.Errorf("계좌 B 생성 실패 (자식): %w", err) // 자식 트랜잭션 롤백
}
fmt.Printf(" 자식 트랜잭션: 계좌 B (%s, ID: %d) 생성 시도\n", accountB.Holder, accountB.ID)
// 자식 트랜잭션 내에서 강제로 오류 발생 (자식 트랜잭션만 롤백)
return fmt.Errorf("자식 트랜잭션 내에서 의도적인 오류 발생") // 이 오류로 인해 자식 트랜잭션만 롤백, 계좌 B는 생성되지 않음
}); err != nil {
fmt.Printf("자식 트랜잭션 실패 감지: %v. 그러나 부모 트랜잭션은 계속 진행\n", err)
}
// 부모 트랜잭션 계속 실행: 계좌 A 잔액 업데이트
if err := parentTx.Model(&accountA).Update("balance", 1500).Error; err != nil {
return fmt.Errorf("계좌 A 잔액 업데이트 실패 (부모): %w", err)
}
fmt.Printf("부모 트랜잭션: 계좌 A (%s) 잔액 업데이트됨 (새 잔액: %d)\n", accountA.Holder, accountA.Balance)
return nil // 부모 트랜잭션 성공 시 커밋
})
}