ORM pour Rust : comparaison et exemples

ORM pour Rust : comparaison détaillée et exemples d'utilisation

L'écosystème Rust propose plusieurs solutions puissantes pour travailler avec les bases de données. Dans cet article, nous examinerons trois ORM (Object-Relational Mapping) les plus populaires pour Rust : Diesel, SeaORM et SQLx. Chacun d'eux a ses points forts et convient à différents scénarios. Nous les comparerons selon des caractéristiques clés et fournirons des exemples pratiques de code.

1. Diesel — l'ORM classique avec des performances maximales

Diesel est l'ORM le plus mature de l'écosystème Rust. Il fonctionne de manière synchrone (avec prise en charge de l'asynchronisme via diesel-async) et est réputé pour ses hautes performances et sa sécurité de typage.

Caractéristiques principales :

Sécurité de typage totale : les erreurs SQL sont détectées à la compilation
Prise en charge de PostgreSQL, MySQL, SQLite
Génération de schéma via l'outil CLI diesel_cli
Optimisé pour les requêtes complexes et les transactions

Exemple de code avec Diesel :

// Définition du modèle#[derive(Queryable, Insertable)]#[diesel(table_name = crate::schema::users)]struct User {    id: i32,    name: String,    email: String,}

// Insertion d'un nouvel utilisateurfn create_user(conn: &mut PgConnection, name: &str, email: &str) -> User {    let new_user = NewUser { name, email };    diesel::insert_into(users::table)        .values(&new_user)        .get_result(conn)        .expect("Erreur lors de l'enregistrement du nouvel utilisateur")}

// Requête de tous les utilisateursfn get_all_users(conn: &mut PgConnection) -> Vec<User> {    users::table        .load::<User>(conn)        .expect("Erreur lors du chargement des utilisateurs")}

2. SeaORM — l'ORM asynchrone avec modèle actif

SeaORM est un ORM asynchrone moderne, inspiré d'Entity Framework et d'Active Record. Il offre une API pratique pour la construction de requêtes et prend en charge les migrations "prêtes à l'emploi".

Caractéristiques principales :

Asynchronisme par défaut (basé sur Tokio)
Modèle actif : possibilité d'appeler des méthodes sur les entités
Prise en charge des relations (has_many, belongs_to, many_to_many)
Migrations intégrées et utilitaire CLI

Exemple de code avec SeaORM :

use sea_orm::{entity::prelude::*, Database, EntityTrait};

// Définition de l'entité#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]#[sea_orm(table_name = "users")]pub struct Model {    #[sea_orm(primary_key)]    pub id: i32,    pub name: String,    pub email: String,}

#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]pub enum Relation {}

impl ActiveModelBehavior for ActiveModel {}

// Utilisation dans le codeasync fn run() {    let db = Database::connect("postgres://user:pass@localhost/db").await.unwrap();        // Insertion    let user = ActiveModel {        name: Set("Alice".to_owned()),        email: Set("alice@example.com".to_owned()),        ..Default::default()    };    let result = Entity::insert(user).exec(&db).await.unwrap();        // Sélection de tous    let users: Vec<Model> = Entity::find().all(&db).await.unwrap();}

3. SQLx — pas un ORM, mais un pilote SQL asynchrone avec vérification à la compilation

SQLx occupe une position intermédiaire : ce n'est pas un ORM complet, mais il fournit des outils puissants pour travailler avec SQL avec vérification des requêtes à la compilation. Il est idéal pour ceux qui préfèrent écrire du SQL pur tout en évitant les erreurs.