ORM pour Go (Golang) : comparaison et exemples d'utilisation

ORM pour Go (Golang) : comparaison et exemples

Le développement en Go (Golang) nécessite souvent une interaction avec des bases de données. Au lieu d'écrire des requêtes SQL brutes, les développeurs ont de plus en plus recours à l'ORM (Object-Relational Mapping) — des outils qui automatisent la transformation des données entre une base de données relationnelle et les objets du langage. Dans cet article, nous allons analyser les quatre ORM les plus populaires pour Go : GORM, Ent, SQLBoiler et Bun. Vous découvrirez leurs forces et leurs faiblesses, verrez des exemples de code et pourrez faire un choix éclairé pour votre projet.

Pourquoi utiliser un ORM en Go ?

Un ORM résout plusieurs problèmes clés :

• Réduction du code boilerplate — inutile d'écrire les opérations CRUD manuellement.
• Sécurité des types — le compilateur Go vérifie la correspondance des champs de la structure avec les colonnes de la table.
• Migrations de schéma — création et mise à jour automatiques des tables.
• Abstraction de la base de données — changement de SGBD (PostgreSQL, MySQL, SQLite) sans réécrire les requêtes.

1. GORM — le choix le plus populaire

GORM est la norme de facto des ORM dans l'écosystème Go. Il est connu pour ses fonctionnalités riches : migrations automatiques, hooks, chaînage de méthodes, prise en charge des transactions et des relations (Has Many, Belongs To, Many2Many).

Exemple de code avec 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")    }

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

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

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

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

    // Suppression    db.Delete(&user)}

Avantages : immense communauté, beaucoup de documentation, prise en charge intégrée des associations et des hooks.

Inconvénients : performances parfois lentes sur les requêtes complexes, comportement magique (par exemple, modification automatique des champs).

2. Ent — génération de code et typage strict

Ent de Facebook (Meta) n'est pas seulement un ORM, mais un véritable framework pour travailler avec des entités. Il génère du code Go à partir d'un schéma décrit en syntaxe Go. Cela offre des performances maximales et une sécurité des types.

Exemple de code avec 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()    // Création des tables    if err := client.Schema.Create(ctx); err != nil {        log.Fatal(err)    }

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

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

Avantages : hautes performances, typage complet, excellente prise en charge des requêtes graphes.

Inconvénients : courbe d'apprentissage abrupte, nécessité de lancer la génération de code, moins de fonctionnalités intégrées (par exemple, pas de hooks).

3. SQLBoiler —