orm/

ORM

Object-Relational Mapping (ORM) tools and query builders for Go.

Overview

The orm package provides working examples and comprehensive documentation for five popular Go database abstraction libraries. Each tool represents a different philosophy for database interaction, from full-featured ORMs to lightweight query builders.

Supported Tools

Quick Comparison

Philosophy

Feature Matrix

Decision Guide

Choose Ent When

• Complex relationships: Your domain has many entity relationships
• Type safety critical: Compile-time guarantees are essential
• Graph queries: You need to traverse relationships efficiently
• Schema evolution: Automatic migration generation is valuable
• Greenfield projects: Starting fresh with code-first approach

📖 Read the Ent Guide

Choose GORM When

• Rapid development: Need to build quickly with minimal boilerplate
• Familiar API: Coming from Rails/ActiveRecord background
• Rich features: Need hooks, associations, auto-migration out of the box
• Large community: Want extensive documentation and plugins
• Learning curve: Need something easy to pick up

📖 Read the GORM Guide

Choose SQLC When

• SQL expertise: You know SQL and want to write it directly
• Performance critical: Need zero runtime overhead
• Type safety: Want compile-time query verification
• Database-specific: Need to use database-specific features
• Simple queries: Mostly straightforward CRUD operations

📖 Read the SQLC Guide

Choose SQLx When

• Minimal abstraction: Want thin layer over database/sql
• Full control: Need complete control over SQL
• Small projects: Don't need heavy ORM machinery
• Learning SQL: Want to improve SQL skills
• Existing code: Migrating from database/sql

📖 Read the SQLx Guide

Choose Beego ORM When

• Beego framework: Already using Beego web framework
• Framework integration: Want tight web framework coupling
• QueryBuilder needed: Mix of ORM and query builder
• Multi-database: Need to support multiple databases easily
• China-focused: Development team is China-based

📖 Read the Beego Guide

Getting Started

See individual guides for detailed installation, configuration, and usage:

• Ent Guide - Schema definition, code generation, graph queries
• GORM Guide - Models, associations, migrations, hooks
• SQLC Guide - SQL queries, code generation, configuration
• SQLx Guide - Struct scanning, named queries, transactions
• Beego Guide - ORM features, QueryBuilder, framework integration

Performance Considerations

Recommendations:

• High performance: SQLC or SQLx for minimal overhead
• Balanced: Ent for type safety with good performance
• Rapid development: GORM for quick iteration
• Control: SQLx for manual optimization

Common Patterns

Connection Management

// Ent
client, err := ent.Open("mysql", dsn)
defer client.Close()

// GORM
db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
sqlDB, _ := db.DB()
defer sqlDB.Close()

// SQLC/SQLx
db, err := sqlx.Connect("mysql", dsn)
defer db.Close()

// Beego
orm.RegisterDataBase("default", "mysql", dsn)

Transaction Handling

// Ent
tx, err := client.Tx(ctx)
if err := txFunc(ctx, tx); err != nil {
    tx.Rollback()
} else {
    tx.Commit()
}

// GORM
db.Transaction(func(tx *gorm.DB) error {
    // operations
    return nil
})

// SQLx
tx, _ := db.Beginx()
defer tx.Rollback()
// operations
tx.Commit()

Migration Between Tools

From database/sql to SQLx

Easiest migration - SQLx extends database/sql interface.

From GORM to Ent

Requires schema redesign but improves type safety.

From Raw SQL to SQLC

Keep your SQL, gain type safety through codegen.

From Any Tool to SQLx

Always possible - SQLx works with any database/sql driver.

Next Steps

Choose a tool from the decision guide above and read its detailed documentation. Each guide includes installation, complete API reference, best practices, testing examples, and troubleshooting.

Resources

• Ent: Documentation | GitHub
• GORM: Documentation | GitHub
• SQLC: Documentation | GitHub
• SQLx: Documentation | GitHub
• Beego: Documentation | GitHub