ORM pour Go (Golang) : comparaison et exemples de bibliothèques populaires

ORM pour Go (Golang) : aperçu, comparaison et exemples pratiques

Go (Golang) est réputé pour ses performances et sa simplicité, mais le travail avec les bases de données nécessite souvent l'écriture d'une grande quantité de code SQL standard. Les bibliothèques ORM (Object-Relational Mapping) visent à simplifier l'interaction avec la BDD en automatisant le mappage des structures Go vers les tables. Dans cet article, nous examinerons les trois ORM les plus populaires pour Go : GORM, Ent et SQLBoiler, nous les comparerons selon des paramètres clés et fournirons des exemples concrets.

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

GORM est un ORM complet avec une communauté active et un grand nombre de fonctionnalités : migrations, hooks, préchargement des relations, transactions et bien plus encore. Il fonctionne selon le principe "convention over configuration" et prend en charge la plupart des SGBD populaires (PostgreSQL, MySQL, SQLite).

Avantages :

• Démarrage rapide : configuration minimale, création automatique des tables.
• Écosystème riche : plugins, loggers, validateurs.
• Prise en charge des associations (Belongs To, Has Many, Many2Many).

Inconvénients :

• Performances moyennes en raison de la réflexion et de la génération SQL à la volée.
• Difficultés d'optimisation des requêtes complexes (problème N+1).

Exemple d'utilisation de GORM :

package main

import (    "gorm.io/driver/sqlite"    "gorm.io/gorm")

type User struct {    ID   uint   `gorm:"primaryKey"`    Name string `gorm:"size:100"`    Age  int}

func main() {    // Connexion à SQLite    db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})    if err != nil {        panic("failed to connect database")    }

    // Automigration — création de la table    db.AutoMigrate(&User{})

    // Création d'un enregistrement    db.Create(&User{Name: "Иван", Age: 30})

    // Lecture    var user User    db.First(&user, 1) // trouver par ID    db.First(&user, "name = ?", "Иван") // trouver par condition

    // Mise à jour    db.Model(&user).Update("Age", 31)

    // Suppression    db.Delete(&user)}

2. Ent — ORM de Facebook avec génération de code

Ent est un ORM moderne qui génère du code Go typé à partir d'un schéma de données décrit dans des structures Go. Il offre un typage strict, d'excellentes performances et une API graphique puissante pour les requêtes. Ent est activement développé et utilisé dans de grands projets (par exemple, chez Facebook lui-même).

Avantages :

• Génération de code : erreurs à la compilation, pas à l'exécution.
• Haute performance grâce au SQL statique.
• API pratique pour construire des requêtes complexes avec filtrage et tri.

Inconvénients :

• Nécessité d'installer un outil CLI et de générer du code.
• Courbe d'apprentissage plus raide par rapport à GORM.

Exemple d'utilisation d'Ent :

package main

import (    "context"    "log"

    "entgo.io/ent/dialect/sqlite"    "github.com/yourproject/ent"    "github.com/yourproject/ent/user")

func main() {    // Connexion à SQLite    client, err := ent.Open("sqlite3", "file:ent.db?cache=shared&_fk=1")    if err != nil {        log.Fatalf("failed opening connection to sqlite: %v", err)    }    defer client.Close()

    // Automigration    if err := client.Schema.Create(context.Background()); err != nil {        log.Fatalf("failed creating schema resources: %v", err)    }

    // Création d'un utilisateur    createdUser, err := client.User.Create().        SetName("Пётр").        SetAge(25).        Save(context.Background())    if err != nil {        log.Fatalf("failed creating user: %v", err)    }

    // Requête avec filtrage    users, err := client.User.Q