ORM para Go (Golang): comparação entre GORM, Ent e sqlx com exemplos

Here is the translated HTML content from Russian to Portuguese (Português), with all HTML tags preserved and only the text content inside tags translated. Programming terms, code examples, and proper nouns remain in English. ```html

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

Ao desenvolver em Go (Golang), trabalhar com bancos de dados é uma das tarefas principais. Ao contrário de muitas linguagens dinâmicas, Go não possui um ORM (Object-Relational Mapping) embutido, mas a comunidade criou várias bibliotecas poderosas. Neste artigo, compararemos detalhadamente três abordagens populares: GORM, Ent e sqlx. Você conhecerá seus pontos fortes e fracos, além de ver exemplos de código para cada biblioteca.

Por que usar um ORM em Go?

O ORM simplifica a interação com bancos de dados relacionais, permitindo trabalhar com tabelas como se fossem estruturas comuns do Go. As principais vantagens são:

• Geração automática de consultas SQL
• Migrações de esquema de banco de dados
• Proteção contra injeção de SQL
• Aceleração do desenvolvimento

No entanto, o ORM pode reduzir o desempenho em consultas complexas e ocultar detalhes do SQL, o que é crítico para projetos de alta carga.

1. GORM — o ORM mais popular para Go

GORM é um ORM completo com uma comunidade ativa (mais de 35k estrelas no GitHub). Ele oferece uma API rica para operações CRUD, migrações, hooks e relacionamentos.

Exemplo de trabalho com GORM

Vamos definir um modelo e realizar operações 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")    }

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

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

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

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

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

Vantagens do GORM:

• API simples e intuitiva
• Suporte a relacionamentos (BelongsTo, HasMany, Many2Many)
• Migrações e hooks integrados
• Amplo suporte a SGBDs (PostgreSQL, MySQL, SQLite, SQL Server)

Desvantagens:

• Redução de desempenho em consultas complexas
• Comportamento mágico (por exemplo, alteração automática de campos)
• Dificuldades com consultas SQL personalizadas

2. Ent — ORM code-first do Facebook

Ent é um ORM baseado em geração de código. Em vez de reflexão, como no GORM, o Ent gera código Go tipado a partir do esquema, garantindo alto desempenho e segurança de tipos.

Exemplo de trabalho com Ent

Primeiro, definimos o esquema no arquivo 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(),    }}

Após a geração do código (comando go generate ./...), usamos a API gerada:

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()

    // Automigração    if err := client.Schema.Create(ctx); err != nil {        log.Fatal(err)    }

    // Criação de usuário    user, err := client.User.Create().        SetName("Bob").        SetEmail("bob@example.com").        Save(ctx)    if err != ni
```