ent para Go: Guía completa del ORM con generación de código

En el mundo del desarrollo con Go existen muchas bibliotecas ORM, pero ent de Facebook (ahora Meta) ocupa un lugar especial. No es solo otro ORM: es un potente framework para trabajar con bases de datos basado en generación de código. En lugar de usar reflexión o interfaces en tiempo de ejecución, ent genera código Go estrictamente tipado a partir de tu esquema de datos. Esto significa que muchos errores relacionados con tipos y consultas se detectan en tiempo de compilación, no en producción.

¿Para qué sirve ent? Si trabajas con bases de datos relacionales (PostgreSQL, MySQL, SQLite) y quieres tipado estricto, autocompletado en el IDE y mínimo código repetitivo, ent es tu opción. Es ideal para proyectos donde el rendimiento y el mantenimiento del código son clave. A diferencia de GORM, que usa reflexión, ent genera código para cada modelo, haciéndolo mucho más rápido y seguro.

En este artículo analizaremos ent en detalle: desde la instalación hasta técnicas avanzadas. Aprenderás a definir un esquema de datos, generar código, realizar operaciones CRUD, construir consultas complejas con grafos de relaciones y evitar errores comunes. El material está pensado para desarrolladores que ya conocen los fundamentos de Go.

Instalación

Para empezar con ent necesitas Go versión 1.16 o superior. La instalación incluye el paquete ent y la herramienta de línea de comandos para la generación de código.

# Instalación de la herramienta de línea de comandos
go install entgo.io/ent/cmd/ent@latest

# Inicialización del proyecto (crea el directorio ent/)
go run entgo.io/ent/cmd/ent init User

El primer comando instala el binario ent en tu $GOPATH/bin. El segundo comando crea la estructura del proyecto: un directorio ent/ con el archivo de esquema para la entidad User. Después de esto, puedes empezar a definir campos y relaciones.

Inicio rápido: ejemplo mínimo funcional

Vamos a crear un modelo simple de usuario y realizar operaciones básicas. Primero, definimos el esquema en el archivo ent/schema/user.go:

package schema

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

// User holds the schema definition for the User entity.
type User struct {
    ent.Schema
}

// Fields of the User.
func (User) Fields() []ent.Field {
    return []ent.Field{
        field.String("name").
            Unique().
            NotEmpty(),
        field.Int("age").
            Positive(),
        field.String("email").
            Unique(),
    }
}

Ahora generamos el código:

go generate ./ent

Después de esto, podemos usar el código generado en main.go:

package main

import (
    "context"
    "fmt"
    "log"

    "your-project/ent"
    "your-project/ent/user"

    _ "github.com/mattn/go-sqlite3"
)

func main() {
    // Creamos un cliente para SQLite (en memoria)
    client, err := ent.Open("sqlite3", "file:ent?mode=memory&cache=shared&_fk=1")
    if err != nil {
        log.Fatalf("error al abrir conexión a sqlite: %v", err)
    }
    defer client.Close()

    // Automigración del esquema
    ctx := context.Background()
    if err := client.Schema.Create(ctx); err != nil {
        log.Fatalf("error al crear recursos del esquema: %v", err)
    }

    // Creamos un usuario
    u, err := client.User.
        Create().
        SetName("Alice").
        SetAge(30).
        SetEmail("alice@example.com").
        Save(ctx)
    if err != nil {
        log.Fatalf("error al crear usuario: %v", err)
    }
    fmt.Printf("Usuario creado: %+v\n", u)

    // Buscamos usuario por nombre
    found, err := client.User.
        Query().
        Where(user.NameEQ("Alice")).
        Only(ctx)
    if err != nil {
        log.Fatalf("error al consultar usuario: %v", err)
    }
    fmt.Printf("Usuario encontrado: %+