Go × GORM × PostgreSQL

go mod init school-app

# GORM core
go get gorm.io/gorm

# Driver PostgreSQL (dùng pgx — hiệu năng cao hơn lib/pq)
go get gorm.io/driver/postgres

package database

import (
  "gorm.io/driver/postgres"
  "gorm.io/gorm"
  "gorm.io/gorm/logger"
  "time"
)

func Connect() *gorm.DB {
  dsn := "host=localhost user=postgres password=secret dbname=school port=5432 sslmode=disable TimeZone=Asia/Ho_Chi_Minh"

  db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
    Logger: logger.Default.LogMode(logger.Info), // in SQL khi dev
  })
  if err != nil {
    log.Fatal("Không kết nối được PostgreSQL:", err)
  }

  sqlDB, _ := db.DB()
  sqlDB.SetMaxIdleConns(10)
  sqlDB.SetMaxOpenConns(100)
  sqlDB.SetConnMaxLifetime(time.Hour)

  return db
}

type Student struct {
  gorm.Model          // tự có: ID, CreatedAt, UpdatedAt, DeletedAt
  Name    string  `gorm:"size:100;not null"`
  Age     int     `gorm:"check:age > 0 AND age < 100"`
  Email   string  `gorm:"uniqueIndex;size:200"`
  Score   float64 `gorm:"default:0;check:score >= 0 AND score <= 10"`
  ClassID uint
}
// Convention: struct "Student" → bảng "students" (tự động snake_case + plural)

// Đặt tên bảng tùy ý
func (Student) TableName() string { return "hs_students" }

// Composite primary key (bảng trung gian)
type Enrollment struct {
  StudentID uint    `gorm:"primaryKey"`
  SubjectID uint    `gorm:"primaryKey"`
  Score     float64
  EnrolledAt time.Time
}

// Embedded struct — tái sử dụng fields
type Address struct {
  Street string
  City   string
}
type Teacher struct {
  gorm.Model
  Name    string
  Address Address `gorm:"embedded;embeddedPrefix:addr_"`
  // → cột: addr_street, addr_city
}

student := Student{
  Name:  "Nguyễn Văn An",
  Age:   16,
  Email: "an@school.edu.vn",
  Score: 8.5,
}
result := db.Create(&student)

if result.Error != nil {
  log.Println("Lỗi:", result.Error)
}

// Sau Create, GORM tự điền ID vào struct!
fmt.Println("ID vừa tạo:", student.ID)
fmt.Println("Rows affected:", result.RowsAffected)

// Tạo nhiều bản ghi
students := []Student{
  {Name: "Trần Thị Bích", Age: 15, Email: "bich@school.edu.vn"},
  {Name: "Lê Văn Cường",  Age: 17, Email: "cuong@school.edu.vn"},
  {Name: "Phạm Thị Dung", Age: 16, Email: "dung@school.edu.vn"},
}
db.Create(&students)

// Batch 100 / lần — tốt cho dữ liệu lớn
db.CreateInBatches(&students, 100)

// FirstOrCreate — tìm theo email, không có thì tạo
var s Student
db.Attrs(Student{Name: "Hoàng Em", Age: 16}).
  FirstOrCreate(&s, Student{Email: "em@school.edu.vn"})

var s  Student
var ss []Student

db.First(&s, 1)          // SELECT * FROM students WHERE id=1 ORDER BY id LIMIT 1
db.Last(&s)              // ORDER BY id DESC LIMIT 1
db.Take(&s, 1)           // không có ORDER BY — nhanh hơn
db.Find(&ss)             // SELECT * FROM students
db.Find(&ss, []int{1,2,3}) // WHERE id IN (1,2,3)

// Xử lý "không tìm thấy"
result := db.First(&s, 999)
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
  fmt.Println("Không tìm thấy")
}

var students []Student

db.Where("age > ?", 15).Find(&students)
db.Where("score BETWEEN ? AND ?", 7.0, 10.0).Find(&students)
db.Where("name ILIKE ?", "%văn%").Find(&students)   // PG: ILIKE
db.Where("age IN ?", []int{15, 16, 17}).Find(&students)
db.Not("class_id = ?", 3).Find(&students)
db.Where("age = ?", 15).Or("age = ?", 16).Find(&students)

// Map condition (không bỏ qua zero value)
db.Where(map[string]interface{}{
  "score": 0,   // sẽ được lọc, không bị bỏ qua
  "age":   16,
}).Find(&students)

page, size := 2, 10
var students []Student
var total    int64

// Đếm tổng
db.Model(&Student{}).Count(&total)

// Lấy trang
db.Order("score DESC").Order("name ASC").
  Limit(size).Offset((page-1)*size).
  Find(&students)

fmt.Printf("Trang %d/%d — %d học sinh\n", page, (total+int64(size)-1)/int64(size), int64(len(students)))

// Chỉ lấy cột cần thiết
var students []Student
db.Select("name, score").Find(&students)

// DTO — struct riêng để nhận kết quả
type StudentDTO struct {
  Name  string
  Score float64
}
var dtos []StudentDTO
db.Model(&Student{}).Select("name, score").Scan(&dtos)

// Pluck — lấy 1 cột thành slice
var names []string
db.Model(&Student{}).Pluck("name", &names)

type Report struct {
  ClassName string
  Total     int64
  AvgScore  float64
}
var reports []Report

db.Model(&Student{}).
  Select("classes.name as class_name, COUNT(students.id) as total, AVG(students.score) as avg_score").
  Joins("JOIN classes ON classes.id = students.class_id").
  Group("classes.name").
  Having("AVG(students.score) > ?", 7.0).
  Order("avg_score DESC").
  Scan(&reports)

// Model có field JSONB
type Product struct {
  gorm.Model
  Name  string
  Meta  datatypes.JSON `gorm:"type:jsonb"`
  // Meta lưu: {"color": "red", "size": "XL", "inStock": true}
}

// Query theo key trong JSONB (PG syntax)
var products []Product

// Lấy sản phẩm màu đỏ
db.Where("meta->>'color' = ?", "red").Find(&products)

// Lấy sản phẩm đang còn hàng
db.Where("(meta->>'inStock')::boolean = true").Find(&products)

// Dùng datatypes helper (gorm.io/datatypes)
db.Where(datatypes.JSONQuery("meta").Equals("red", "color")).Find(&products)

// Cộng thêm điểm (dùng giá trị hiện tại trong DB)
db.Model(&Student{}).Where("id = ?", 1).
  Update("score", gorm.Expr("score + ?", 0.5))

// Tăng điểm tất cả học sinh lớp 1 lên 10%
db.Model(&Student{}).Where("class_id = ?", 1).
  Updates(map[string]interface{}{
    "score": gorm.Expr("LEAST(score * 1.1, 10)"), // LEAST: không vượt 10
  })

var updated Student

// Cập nhật và lấy lại bản ghi sau khi update — 1 round trip!
db.Model(&Student{}).Where("id = ?", 1).
  Clauses(clause.Returning{}).
  Updates(Student{Score: 9.5, Name: "Tên mới"})

// MySQL: phải UPDATE rồi SELECT riêng = 2 round trips

var s Student
db.First(&s, 1)
s.Name = "Tên mới"; s.Score = 10.0; s.Age = 20

// Chỉ update Name, Score — bỏ qua Age
db.Model(&s).Select("Name", "Score").Updates(&s)

// Update tất cả TRỪ Age
db.Model(&s).Omit("Age").Updates(&s)

// ── Soft Delete ──
var s Student
db.First(&s, 1)
db.Delete(&s)
// SQL: UPDATE students SET deleted_at=NOW() WHERE id=1

// Xoá theo điều kiện
db.Where("score < ?", 3.0).Delete(&Student{})

// Xoá theo nhiều ID
db.Delete(&Student{}, []int{1, 2, 3})

// ── Hard Delete vĩnh viễn ──
db.Unscoped().Delete(&s)
// SQL: DELETE FROM students WHERE id=1

var students []Student

// Mặc định GORM tự thêm: WHERE deleted_at IS NULL
db.Find(&students)  // chỉ học sinh chưa xoá

// Lấy cả đã xoá lẫn chưa xoá
db.Unscoped().Find(&students)

// Chỉ lấy bản ghi đã xoá mềm
db.Unscoped().Where("deleted_at IS NOT NULL").Find(&students)

// Khôi phục — set deleted_at về NULL
var s Student
db.Unscoped().First(&s, 1)
db.Unscoped().Model(&s).Update("deleted_at", nil)

type Class struct {
  gorm.Model
  Name     string
  Teacher  string
  Students []Student  // HasMany — GORM biết ClassID là khoá ngoại
}

type Student struct {
  gorm.Model
  Name    string
  Score   float64
  ClassID uint   // khoá ngoại
  Class   Class  // BelongsTo
}

// Tạo lớp kèm học sinh trong 1 lệnh
db.Create(&Class{
  Name: "10A", Teacher: "Thầy Minh",
  Students: []Student{
    {Name: "An", Score: 8.5},
    {Name: "Bình", Score: 9.0},
  },
})

type Student struct {
  gorm.Model
  Name     string
  Subjects []Subject `gorm:"many2many:student_subjects;"`
}

type Subject struct {
  gorm.Model
  Name     string
  Students []Student `gorm:"many2many:student_subjects;"`
}
// PG tự tạo bảng: student_subjects(student_id BIGINT, subject_id BIGINT)
// Dùng kiểu BIGINT (không phải INT như MySQL mặc định)

// Thêm môn học cho học sinh
var s Student
db.First(&s, 1)
db.Model(&s).Association("Subjects").Append(&Subject{Name: "Toán"})

var class  Class
var classes []Class

// Load kèm học sinh
db.Preload("Students").First(&class, 1)

// Preload có điều kiện — chỉ load học sinh giỏi
db.Preload("Students", "score >= ?", 8.0).Find(&classes)

// Preload lồng nhau: Class → Students → Subjects
db.Preload("Students.Subjects").Find(&classes)

// Load tất cả associations
db.Preload(clause.Associations).Find(&classes)

// Association Mode — quản lý liên kết
var s Student
db.First(&s, 1)
count := db.Model(&s).Association("Subjects").Count()
db.Model(&s).Association("Subjects").Delete(&Subject{ID: 2})
db.Model(&s).Association("Subjects").Replace([]Subject{{Name: "Hoá"}})

type Student struct {
  gorm.Model
  Name     string
  Email    string
  Password string
  Score    float64
}

// 1. Validate + chuẩn hoá trước khi lưu
func (s *Student) BeforeSave(tx *gorm.DB) error {
  if s.Score < 0 || s.Score > 10 {
    return errors.New("điểm phải từ 0 đến 10")
  }
  // Chuẩn hoá email — chữ thường, bỏ khoảng trắng
  s.Email = strings.ToLower(strings.TrimSpace(s.Email))
  // Viết hoa chữ cái đầu tên
  s.Name  = cases.Title(language.Vietnamese).String(s.Name)
  return nil
}

// 2. Hash mật khẩu trước khi tạo
func (s *Student) BeforeCreate(tx *gorm.DB) error {
  if !strings.HasPrefix(s.Password, "$2a$") {
    hashed, err := bcrypt.GenerateFromPassword([]byte(s.Password), 12)
    if err != nil { return err }
    s.Password = string(hashed)
  }
  return nil
}

// 3. Ghi log sau khi tạo
func (s *Student) AfterCreate(tx *gorm.DB) error {
  log.Printf("[NEW] Học sinh: id=%d name=%s\n", s.ID, s.Name)
  return nil
}

// 4. Bảo vệ học sinh giỏi không bị xoá
func (s *Student) BeforeDelete(tx *gorm.DB) error {
  if s.Score >= 9.0 {
    return errors.New("không thể xoá học sinh xuất sắc")
  }
  return nil
}

func enrollStudent(db *gorm.DB, studentID, classID uint) error {
  return db.Transaction(func(tx *gorm.DB) error {

    // Cập nhật lớp cho học sinh
    if err := tx.Model(&Student{}).Where("id = ?", studentID).
      Update("class_id", classID).Error; err != nil {
      return err  // tự động ROLLBACK
    }

    // Tăng số học sinh trong lớp
    if err := tx.Model(&Class{}).Where("id = ?", classID).
      Update("student_count", gorm.Expr("student_count + 1")).Error; err != nil {
      return err  // tự động ROLLBACK
    }

    return nil  // tự động COMMIT
  })
}

tx := db.Begin()
defer func() {
  if r := recover(); r != nil { tx.Rollback() }
}()

tx.Create(&Student{Name: "Học sinh 1"})

// Đánh dấu điểm khôi phục
tx.SavePoint("sp1")

tx.Create(&Student{Name: "Học sinh 2"})

// Rollback về sp1 — Học sinh 2 bị hủy, Học sinh 1 còn
tx.RollbackTo("sp1")

tx.Commit()  // chỉ có Học sinh 1

// Học sinh xuất sắc
func Excellent(db *gorm.DB) *gorm.DB {
  return db.Where("score >= ?", 9.0)
}

// Học sinh theo lớp
func InClass(classID uint) func(*gorm.DB) *gorm.DB {
  return func(db *gorm.DB) *gorm.DB {
    return db.Where("class_id = ?", classID)
  }
}

// Phân trang
func Paginate(page, size int) func(*gorm.DB) *gorm.DB {
  return func(db *gorm.DB) *gorm.DB {
    return db.Offset((page - 1) * size).Limit(size)
  }
}

// Tìm theo tên (PG: ILIKE không phân biệt hoa/thường)
func NameContains(keyword string) func(*gorm.DB) *gorm.DB {
  return func(db *gorm.DB) *gorm.DB {
    return db.Where("name ILIKE ?", "%"+keyword+"%")
    // ILIKE: đặc trưng PG, không cần phân biệt hoa/thường
  }
}

// Sử dụng — kết hợp linh hoạt
var students []Student
db.Scopes(Excellent, InClass(2), Paginate(1, 10)).
  Order("score DESC").
  Find(&students)

// Raw SELECT — scan vào slice struct
var students []Student
db.Raw("SELECT * FROM students WHERE age > ? AND score > ?", 15, 7.0).Scan(&students)

// Scan vào DTO
type Report struct { ClassID uint; Count int; AvgScore float64 }
var reports []Report
db.Raw(`SELECT class_id, COUNT(*) as count, AVG(score) as avg_score FROM students GROUP BY class_id`).Scan(&reports)

// Exec — INSERT / UPDATE / DELETE thủ công
db.Exec("UPDATE students SET score = ? WHERE class_id = ?", 9.0, 2)

// CTE: tìm học sinh có điểm cao nhất mỗi lớp
type TopStudent struct {
  ClassID uint; Name string; Score float64
}
var tops []TopStudent

db.Raw(`
  WITH ranked AS (
    SELECT *,
      ROW_NUMBER() OVER (PARTITION BY class_id ORDER BY score DESC) AS rn
    FROM students
    WHERE deleted_at IS NULL
  )
  SELECT class_id, name, score
  FROM ranked
  WHERE rn = 1
`).Scan(&tops)

var students []Student

// Dùng @tên thay vì ? — dễ đọc hơn
db.Raw("SELECT * FROM students WHERE name ILIKE @name OR email = @email",
  map[string]interface{}{
    "name":  "%an%",
    "email": "an@school.edu.vn",
  },
).Scan(&students)

// Tạo / cập nhật tất cả bảng theo struct
err := db.AutoMigrate(
  &Student{},
  &Class{},
  &Subject{},
  &Teacher{},
)
if err != nil {
  log.Fatal("Migration thất bại:", err)
}
// AutoMigrate chỉ THÊM cột / index mới, KHÔNG XOÁ cột cũ

m := db.Migrator()

// ── Bảng ──
m.HasTable(&Student{})           // bool
m.CreateTable(&Student{})
m.DropTable(&Student{})
m.RenameTable("students", "pupils")
m.GetTables()                   // []string

// ── Cột ──
m.HasColumn(&Student{}, "Score")
m.AddColumn(&Student{}, "Phone")
m.DropColumn(&Student{}, "Phone")
m.AlterColumn(&Student{}, "Score")
m.RenameColumn(&Student{}, "Score", "GradePoint")

// ── Index ──
m.HasIndex(&Student{}, "idx_email")
m.CreateIndex(&Student{}, "idx_email")
m.DropIndex(&Student{}, "idx_email")

// ── Constraint ──
m.HasConstraint(&Student{}, "fk_class")
m.CreateConstraint(&Student{}, "fk_class")
m.DropConstraint(&Student{}, "fk_class")

type Student struct {
  gorm.Model
  Name   string
  Hobbies pq.StringArray `gorm:"type:text[]"`
  Scores  pq.Float64Array `gorm:"type:float[]"`
}

// Tạo học sinh với mảng
db.Create(&Student{
  Name:    "An",
  Hobbies: pq.StringArray{"đọc sách", "bóng đá", "lập trình"},
  Scores:  pq.Float64Array{8.5, 9.0, 7.5},
})

// Query: tìm học sinh có hobby "bóng đá"
var students []Student
db.Where("? = ANY(hobbies)", "bóng đá").Find(&students)

// Query: tìm học sinh có TẤT CẢ hobby này
db.Where("hobbies @> ?", pq.StringArray{"đọc sách", "lập trình"}).Find(&students)

// Query: tìm học sinh có ÍT NHẤT 1 hobby trong danh sách
db.Where("hobbies && ?", pq.StringArray{"bóng đá", "võ thuật"}).Find(&students)

// pgx COPY — import 100,000 rows trong vài giây
// Nhanh hơn INSERT 10-50x
import "github.com/jackc/pgx/v5/pgxpool"

func BulkInsertStudents(pool *pgxpool.Pool, students []Student) error {
  rows := make([][]interface{}, len(students))
  for i, s := range students {
    rows[i] = []interface{}{s.Name, s.Age, s.Email, s.Score}
  }

  _, err := pool.CopyFrom(
    context.Background(),
    pgx.Identifier{"students"},
    []string{"name", "age", "email", "score"},
    pgx.CopyFromRows(rows),
  )
  return err
}

// Xem SQL được tạo ra
db.Debug().Where("score > ?", 8).Find(&students)

// DryRun — chỉ tạo SQL, không chạy
stmt := db.Session(&gorm.Session{DryRun: true}).
  Where("class_id = ?", 1).Find(&students).Statement

fmt.Println("SQL:", stmt.SQL.String())
fmt.Println("Params:", stmt.Vars)

// Prepared statement — cache để query nhanh hơn
fastDB := db.Session(&gorm.Session{PrepareStmt: true})

school-app/
├── main.go
├── database/
│   └── db.go           // Connect + pool config
├── models/
│   ├── teacher.go
│   ├── class.go
│   ├── student.go      // hooks, pq.StringArray, jsonb
│   └── subject.go
├── services/
│   ├── class.go        // GetClassReport
│   ├── student.go      // TopStudents, Search, FindByHobby
│   └── import.go       // BulkImportScores (Upsert)
├── scopes/
│   └── student.go      // Excellent, InClass, Paginate, NameContains (ILIKE)
└── seed/
    └── seed.go