ORM para Go (Golang): comparação e exemplos de uso

ORM para Go (Golang): comparação e exemplos

O desenvolvimento em Go (Golang) frequentemente requer interação com bancos de dados. Em vez de escrever consultas SQL brutas, os desenvolvedores recorrem cada vez mais ao ORM (Object-Relational Mapping) — ferramentas que automatizam a conversão de dados entre um banco de dados relacional e objetos da linguagem. Neste artigo, analisaremos os quatro ORMs mais populares para Go: GORM, Ent, SQLBoiler e Bun. Você conhecerá seus pontos fortes e fracos, verá exemplos de código e poderá fazer uma escolha consciente para seu projeto.

Por que usar ORM em Go?

O ORM resolve várias tarefas principais:

• Redução de código boilerplate — não é necessário escrever operações CRUD manualmente.
• Segurança de tipos — o compilador Go verifica a correspondência dos campos da estrutura com as colunas da tabela.
• Migrações de esquema — criação e atualização automática de tabelas.
• Abstração do banco de dados — troca de SGBD (PostgreSQL, MySQL, SQLite) sem reescrever consultas.

1. GORM — a escolha mais popular

GORM é o padrão de facto de ORM no ecossistema Go. Ele é conhecido por sua rica funcionalidade: migrações automáticas, hooks, encadeamento de métodos, suporte a transações e relacionamentos (Has Many, Belongs To, Many2Many).

Exemplo de código com 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")    }

    // Automigração    db.AutoMigrate(&User{})

    // Inserção    db.Create(&User{Name: "Alice", Email: "alice@example.com"})

    // Leitura    var user User    db.First(&user, 1) // pela chave primária    db.First(&user, "email = ?", "alice@example.com")

    // Atualização    db.Model(&user).Update("Name", "Bob")

    // Exclusão    db.Delete(&user)}

Prós: enorme comunidade, muita documentação, suporte embutido para associações e hooks.

Contras: às vezes desempenho lento em consultas complexas, comportamento mágico (por exemplo, alteração automática de campos).

2. Ent — geração de código e tipagem estrita

Ent do Facebook (Meta) não é apenas um ORM, mas sim um framework completo para trabalhar com entidades. Ele gera código Go com base em um esquema descrito na sintaxe Go. Isso proporciona desempenho máximo e segurança de tipos.

Exemplo de código com 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()    // Criação de tabelas    if err := client.Schema.Create(ctx); err != nil {        log.Fatal(err)    }

    // Inserção    u, _ := client.User.Create().SetName("Alice").SetEmail("alice@example.com").Save(ctx)

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

Prós: alto desempenho, tipagem completa, excelente suporte para consultas em grafo.

Contras: curva de aprendizado íngreme, necessidade de executar geração de código, menos recursos embutidos (por exemplo, sem hooks).

3. SQLBoiler —