ORM für Rust: Vergleich und Beispiele

ORM für Rust: detaillierter Vergleich und Anwendungsbeispiele

Das Rust-Ökosystem bietet mehrere leistungsstarke Lösungen für die Arbeit mit Datenbanken. In diesem Artikel betrachten wir drei der beliebtesten ORMs (Object-Relational Mapping) für Rust: Diesel, SeaORM und SQLx. Jedes hat seine Stärken und eignet sich für verschiedene Szenarien. Wir vergleichen sie anhand wichtiger Merkmale und geben praktische Codebeispiele.

1. Diesel — klassisches ORM mit maximaler Leistung

Diesel ist das ausgereifteste ORM im Rust-Ökosystem. Es arbeitet synchron (mit Unterstützung für Asynchronität durch diesel-async) und ist bekannt für seine hohe Leistung und Typsicherheit.

Hauptmerkmale:

Vollständige Typsicherheit: SQL-Fehler werden zur Kompilierzeit erkannt
Unterstützung für PostgreSQL, MySQL, SQLite
Schemagenerierung über das CLI-Tool diesel_cli
Optimiert für komplexe Abfragen und Transaktionen

Codebeispiel mit Diesel:

// Definition des Modells#[derive(Queryable, Insertable)]#[diesel(table_name = crate::schema::users)]struct User {    id: i32,    name: String,    email: String,}

// Einfügen eines neuen Benutzersfn 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("Fehler beim Speichern des neuen Benutzers")}

// Abfrage aller Benutzerfn get_all_users(conn: &mut PgConnection) -> Vec<User> {    users::table        .load::<User>(conn)        .expect("Fehler beim Laden der Benutzer")}

2. SeaORM — asynchrones ORM mit aktivem Modell

SeaORM ist ein modernes asynchrones ORM, inspiriert von Entity Framework und Active Record. Es bietet eine benutzerfreundliche API zum Erstellen von Abfragen und unterstützt Migrationen "out of the box".

Hauptmerkmale:

Standardmäßig asynchron (basiert auf Tokio)
Aktives Modell: Methoden können direkt auf Entitäten aufgerufen werden
Unterstützung für Beziehungen (has_many, belongs_to, many_to_many)
Integrierte Migrationen und CLI-Dienstprogramm

Codebeispiel mit SeaORM:

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

// Definition der Entität#[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 {}

// Verwendung im Codeasync fn run() {    let db = Database::connect("postgres://user:pass@localhost/db").await.unwrap();        // Einfügen    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();        // Alle abrufen    let users: Vec<Model> = Entity::find().all(&db).await.unwrap();}

3. SQLx — kein ORM, sondern ein asynchroner SQL-Treiber mit Kompilierzeitprüfung

SQLx nimmt eine Zwischenposition ein: Es ist kein vollwertiges ORM, bietet aber leistungsstarke Werkzeuge für die Arbeit mit SQL mit Abfrageprüfung zur Kompilierzeit. Es ist ideal für diejenigen, die reines SQL schreiben möchten, aber Fehler vermeiden wollen.