ent Go : méthodes, exemples, installation

Qu'est-ce qu'ent et pourquoi l'utiliser ?

ent est une puissante bibliothèque ORM (Object-Relational Mapping) pour le langage Go, qui repose sur une approche de génération de code. Contrairement aux ORM traditionnels où vous écrivez manuellement les structures et les annotations, ent génère l'intégralité du code à partir de votre schéma de données décrit en Go.

Les principaux avantages d'ent :

Sécurité des types : Toutes les requêtes sont vérifiées à la compilation, éliminant les erreurs d'exécution liées à des noms de champs ou des types incorrects.
Génération de code : Vous décrivez le schéma une seule fois, et ent génère toutes les structures nécessaires, les constructeurs de requêtes, les migrations et même les tests.
Performance : Le code généré est optimisé et n'utilise pas la réflexion, ce qui le rend plus rapide que de nombreux autres ORM.
Requêtes graphes : ent permet d'effectuer facilement des requêtes avec chargement des entités associées (Eager Loading) et de construire des requêtes graphes complexes.
Support de multiples bases de données : MySQL, PostgreSQL, SQLite, Gremlin (pour les bases de données graphes) et autres.

ent est idéal pour les projets où la fiabilité, la performance et un typage strict sont essentiels. Il est fréquemment utilisé dans les architectures microservices, les systèmes à forte charge et les projets nécessitant une structure de données claire.

Installation

L'installation d'ent comprend deux composants : la bibliothèque elle-même et l'outil CLI pour la génération de code.

# Installation de l'outil CLI (une seule fois)
go install entgo.io/ent/cmd/ent@latest

# Initialisation du projet (création du dossier ent et du schéma)
ent init User

# Installation des dépendances
go mod tidy

Après avoir exécuté ces commandes, vous obtiendrez un dossier ent/ avec le fichier schema/user.go, où vous décrirez votre schéma de données.

Démarrage rapide avec un exemple de code

Créons un modèle utilisateur simple et apprenons à effectuer les opérations de base.

1. Description du schéma (ent/schema/user.go)

package schema

import (
    "entgo.io/ent"
    "entgo.io/ent/schema/field"
)

// User contient la définition du schéma pour l'entité User.
type User struct {
    ent.Schema
}

// Fields de l'utilisateur.
func (User) Fields() []ent.Field {
    return []ent.Field{
        field.String("name").
            NotEmpty().
            Unique(),
        field.Int("age").
            Positive(),
        field.String("email").
            Unique(),
    }
}

2. Génération du code

go generate ./ent

Cette commande crée tous les fichiers nécessaires : client, constructeurs de requêtes, migrations, etc.

3. Utilisation dans main.go

package main

import (
    "context"
    "fmt"
    "log"

    "your-project/ent"
    "your-project/ent/user"
    _ "github.com/mattn/go-sqlite3"
)

func main() {
    // Création d'un client pour SQLite (en mémoire)
    client, err := ent.Open("sqlite3", "file:ent?mode=memory&cache=shared&_fk=1")
    if err != nil {
        log.Fatalf("échec de l'ouverture de la connexion à sqlite : %v", err)
    }
    defer client.Close()

    // Automigration
    ctx := context.Background()
    if err := client.Schema.Create(ctx); err != nil {
        log.Fatalf("échec de la création des ressources du schéma : %v", err)
    }

    // Création d'un utilisateur
    newUser, err := client.User.
        Create().
        SetName("Alice").
        SetAge(30).
        SetEmail("alice@example.com").
        Save(ctx)
    if err != nil {
        log.Fatalf("échec de la création de l'utilisateur : %v", err)
    }
    fmt.Println("Utilisateur créé :", newUser.ID)

    // Requête d'un utilisateur par son nom
    foundUser, err := client.User.
        Query().
        Where(user.Name("Alice")).
        Only(ctx)
    if err != nil {
        log.Fatalf("échec de la requête utilisateur : %v", err)
    }
    fmt.Printf("Utilisateur trouvé : %+v\n", foundUser)
}