ORM para Go (Golang): comparación de GORM, Ent y sqlx con ejemplos

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

Al desarrollar en Go (Golang), trabajar con bases de datos es una de las tareas clave. A diferencia de muchos lenguajes dinámicos, Go no tiene un ORM (Object-Relational Mapping) incorporado, pero la comunidad ha creado varias bibliotecas potentes. En este artículo, compararemos en detalle tres enfoques populares: GORM, Ent y sqlx. Conocerás sus fortalezas y debilidades, y también verás ejemplos de código para cada biblioteca.

¿Por qué se necesita un ORM en Go?

Un ORM simplifica la interacción con bases de datos relacionales, permitiendo trabajar con tablas como si fueran estructuras comunes de Go. Las principales ventajas son:

• Generación automática de consultas SQL
• Migraciones del esquema de la base de datos
• Protección contra inyecciones SQL
• Aceleración del desarrollo

Sin embargo, un ORM puede reducir el rendimiento en consultas complejas y ocultar detalles de SQL, lo cual es crítico para proyectos de alta carga.

1. GORM — el ORM más popular para Go

GORM es un ORM con todas las funcionalidades y una comunidad activa (más de 35k estrellas en GitHub). Proporciona una API rica para operaciones CRUD, migraciones, hooks y relaciones.

Ejemplo de trabajo con GORM

Definamos un modelo y realicemos operaciones simples:

package main

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

type User struct {    ID    uint   `gorm:"primaryKey"`    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{})

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

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

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

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

Ventajas de GORM:

• API simple e intuitiva
• Soporte de relaciones (BelongsTo, HasMany, Many2Many)
• Migraciones y hooks integrados
• Amplio soporte de SGBD (PostgreSQL, MySQL, SQLite, SQL Server)

Desventajas:

• Reducción del rendimiento en consultas complejas
• Comportamiento mágico (por ejemplo, modificación automática de campos)
• Dificultades con consultas SQL personalizadas

2. Ent — ORM code-first de Facebook

Ent es un ORM basado en generación de código. En lugar de usar reflexión como GORM, Ent genera código Go tipificado a partir de un esquema, lo que garantiza alto rendimiento y seguridad de tipos.

Ejemplo de trabajo con Ent

Primero, definamos el esquema en el archivo schema/user.go:

package 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(),    }}

Después de generar el código (comando go generate ./...), usamos la API generada:

package main

import (    "context"    "log"

    "your-project/ent"    _ "github.com/mattn/go-sqlite3")

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

    ctx := context.Background()

    // Automigración    if err := client.Schema.Create(ctx); err != nil {        log.Fatal(err)    }

    // Creación de usuario    user, err := client.User.Create().        SetName("Bob").        SetEmail("bob@example.com").        Save(ctx)    if err != ni