ORM para Go (Golang): comparación y ejemplos de uso

ORM para Go (Golang): comparación y ejemplos

El desarrollo en Go (Golang) a menudo requiere interactuar con bases de datos. En lugar de escribir consultas SQL en bruto, los desarrolladores recurren cada vez más a ORM (Object-Relational Mapping) — herramientas que automatizan la transformación de datos entre la base de datos relacional y los objetos del lenguaje. En este artículo, analizaremos los cuatro ORM más populares para Go: GORM, Ent, SQLBoiler y Bun. Conocerás sus fortalezas y debilidades, verás ejemplos de código y podrás tomar una decisión informada para tu proyecto.

¿Por qué se necesita un ORM en Go?

Un ORM resuelve varias tareas clave:

• Reducción de código boilerplate — no es necesario escribir operaciones CRUD manualmente.
• Seguridad de tipos — el compilador de Go verifica la correspondencia de los campos de la estructura con las columnas de la tabla.
• Migraciones de esquema — creación y actualización automática de tablas.
• Abstracción de BD — cambio de SGBD (PostgreSQL, MySQL, SQLite) sin reescribir consultas.

1. GORM — la opción más popular

GORM es el estándar de facto de ORM en el ecosistema Go. Es conocido por su rica funcionalidad: migraciones automáticas, hooks, encadenamiento de métodos, soporte de transacciones y relaciones (Has Many, Belongs To, Many2Many).

Ejemplo de código con GORM

package main

import (    "gorm.io/driver/sqlite"    "gorm.io/gorm")

type User struct {    gorm.Model    Name  string    Email string `gorm:"uniqueIndex"`}

func main() {    db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})    if err != nil {        panic("failed to connect database")    }

    // Automigración    db.AutoMigrate(&User{})

    // Inserción    db.Create(&User{Name: "Alice", Email: "alice@example.com"})

    // Lectura    var user User    db.First(&user, 1) // por clave primaria    db.First(&user, "email = ?", "alice@example.com")

    // Actualización    db.Model(&user).Update("Name", "Bob")

    // Eliminación    db.Delete(&user)}

Ventajas: comunidad enorme, mucha documentación, soporte integrado de asociaciones y hooks.

Desventajas: a veces rendimiento lento en consultas complejas, comportamiento mágico (por ejemplo, modificación automática de campos).

2. Ent — generación de código y tipado estricto

Ent de Facebook (Meta) no es solo un ORM, sino un framework completo para trabajar con entidades. Genera código Go basado en un esquema descrito en sintaxis Go. Esto proporciona el máximo rendimiento y seguridad de tipos.

Ejemplo de código con Ent

// schema/user.gopackage schema

import (    "entgo.io/ent"    "entgo.io/ent/schema/field")

type User struct {    ent.Schema}

func (User) Fields() []ent.Field {    return []ent.Field{        field.String("name"),        field.String("email").Unique(),    }}

// main.gopackage main

import (    "context"    "log"

    "entgo.io/ent/dialect/sqlite"    "yourproject/ent")

func main() {    client, err := ent.Open("sqlite3", "file:ent.db?cache=shared&mode=rwc")    if err != nil {        log.Fatal(err)    }    defer client.Close()

    ctx := context.Background()    // Creación de tablas    if err := client.Schema.Create(ctx); err != nil {        log.Fatal(err)    }

    // Inserción    u, _ := client.User.Create().SetName("Alice").SetEmail("alice@example.com").Save(ctx)

    // Lectura    user, _ := client.User.Get(ctx, u.ID)    log.Println(user.Name)}

Ventajas: alto rendimiento, tipado completo, excelente soporte para consultas de grafos.

Desventajas: curva de aprendizaje pronunciada, necesidad de ejecutar generación de código, menos funciones integradas (por ejemplo, no tiene hooks).

3. SQLBoiler —