Best Practices for Structuring Models and Queries in GORM

When building Go applications with GORM, proper structuring of models and queries isn’t just about making your code work – it’s about making it maintainable, efficient, and scalable. Let’s dive into some battle-tested best practices that will help you make the most of GORM in your projects.

Model Structure Organization

One of the fundamental aspects of working with GORM is organizing your models effectively. Consider structuring your models with embedded interfaces and composition to keep your code DRY and maintainable:

type Model struct {
  ID        uint      `gorm:"primarykey"`
  CreatedAt time.Time
  UpdatedAt time.Time
  DeletedAt gorm.DeletedAt `gorm:"index"`
}

type User struct {
  Model
  Name     string  `gorm:"size:255;not null"`
  Email    string  `gorm:"uniqueIndex;not null"`
  Profile  Profile `gorm:"foreignKey:UserID"`
}

Query Optimization Techniques

The way you structure your queries can significantly impact your application’s performance. Here are some proven patterns:

1. Preloading Relationships Wisely

Instead of loading everything eagerly, use specific preloads:

// Good Practice
db.Preload("Profile").Preload("Orders", "status = ?", "completed").Find(&users)

2. Batch Processing

When dealing with large datasets, implement batch processing:

// Good Practice
db.Where("processed = ?", false).FindInBatches(&results, 100, func(tx *gorm.DB, batch int) error {
    // Process batch
    return nil
})

Index Strategy

Proper indexing is crucial for query performance. Consider these indexing patterns:

type Product struct {
    ID          uint    `gorm:"primarykey"`
    Code        string  `gorm:"uniqueIndex:idx_code"`
    Price       float64 `gorm:"index:idx_price"`
    CategoryID  uint    `gorm:"index"`
}

Error Handling and Transactions

Always wrap critical operations in transactions and implement proper error handling:

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

if err := tx.Error; err != nil {
    return err
}

// Perform operations...
if err := tx.Commit().Error; err != nil {
    return err
}

When implementing these practices, remember that the goal is to create maintainable and efficient code that can scale with your application’s needs. Regular profiling and monitoring will help you identify areas where these patterns can be optimized further.