ORM pour Go (Golang) : comparaison de GORM, Ent et sqlx avec exemples

ORM pour Go (Golang) : comparaison et exemples

Lors du développement en Go (Golang), le travail avec les bases de données est l'une des tâches clés. Contrairement à de nombreux langages dynamiques, Go ne dispose pas d'ORM (Object-Relational Mapping) intégré, mais la communauté a créé plusieurs bibliothèques puissantes. Dans cet article, nous comparerons en détail trois approches populaires : GORM, Ent et sqlx. Vous découvrirez leurs forces et faiblesses, ainsi que des exemples de code pour chaque bibliothèque.

Pourquoi un ORM en Go ?

Un ORM simplifie l'interaction avec les bases de données relationnelles, permettant de travailler avec les tables comme avec des structures Go classiques. Les principaux avantages :

• Génération automatique de requêtes SQL
• Migrations de schéma de base de données
• Protection contre les injections SQL
• Accélération du développement

Cependant, un ORM peut réduire les performances sur les requêtes complexes et masquer les détails SQL, ce qui est critique pour les projets à forte charge.

1. GORM — l'ORM le plus populaire pour Go

GORM est un ORM complet avec une communauté active (plus de 35k étoiles sur GitHub). Il offre une API riche pour les opérations CRUD, les migrations, les hooks et les relations.

Exemple d'utilisation de GORM

Définissons un modèle et effectuons des opérations 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")    }

    // Automigration    db.AutoMigrate(&User{})

    // Création    db.Create(&User{Name: "Alice", Email: "alice@example.com"})

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

    // Mise à jour    db.Model(&user).Update("Name", "Alice Updated")

    // Suppression    db.Delete(&user)}

Avantages de GORM :

• API simple et intuitive
• Prise en charge des relations (BelongsTo, HasMany, Many2Many)
• Migrations et hooks intégrés
• Large prise en charge des SGBD (PostgreSQL, MySQL, SQLite, SQL Server)

Inconvénients :

• Réduction des performances sur les requêtes complexes
• Comportement magique (par exemple, modification automatique des champs)
• Difficultés avec les requêtes SQL personnalisées

2. Ent — ORM code-first de Facebook

Ent est un ORM basé sur la génération de code. Au lieu de la réflexion, comme dans GORM, Ent génère du code Go typé à partir d'un schéma, ce qui garantit des performances élevées et la sécurité des types.

Exemple d'utilisation de Ent

Définissons d'abord le schéma dans le fichier 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(),    }}

Après la génération du code (commande go generate ./...), utilisez l'API générée :

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

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

    // Création d'un utilisateur    user, err := client.User.Create().        SetName("Bob").        SetEmail("bob@example.com").        Save(ctx)    if err != ni