ORM para Rust: comparación y ejemplos

ORM para Rust: comparación detallada y ejemplos de uso

El ecosistema de Rust ofrece varias soluciones potentes para trabajar con bases de datos. En este artículo, analizaremos los tres ORM (Object-Relational Mapping) más populares para Rust: Diesel, SeaORM y SQLx. Cada uno tiene sus puntos fuertes y es adecuado para diferentes escenarios. Los compararemos según características clave y proporcionaremos ejemplos prácticos de código.

1. Diesel — el ORM clásico con máximo rendimiento

Diesel es el ORM más maduro en el ecosistema de Rust. Funciona de forma síncrona (con soporte para asincronía a través de diesel-async) y es conocido por su alto rendimiento y seguridad de tipos.

Características principales:

Seguridad total de tipos: los errores SQL se detectan en tiempo de compilación
Soporte para PostgreSQL, MySQL, SQLite
Generación de esquemas mediante la herramienta CLI diesel_cli
Optimizado para consultas complejas y transacciones

Ejemplo de código con Diesel:

// Definición del modelo#[derive(Queryable, Insertable)]#[diesel(table_name = crate::schema::users)]struct User {    id: i32,    name: String,    email: String,}

// Inserción de un nuevo usuariofn 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("Error saving new user")}

// Consulta de todos los usuariosfn get_all_users(conn: &mut PgConnection) -> Vec<User> {    users::table        .load::<User>(conn)        .expect("Error loading users")}

2. SeaORM — ORM asíncrono con modelo activo

SeaORM es un ORM asíncrono moderno, inspirado en Entity Framework y Active Record. Proporciona una API conveniente para construir consultas y admite migraciones "listas para usar".

Características principales:

Asincronía por defecto (basada en Tokio)
Modelo activo: se pueden llamar métodos en las entidades
Soporte para relaciones (has_many, belongs_to, many_to_many)
Migraciones integradas y utilidad CLI

Ejemplo de código con SeaORM:

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

// Definición de la entidad#[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 {}

// Uso en códigoasync fn run() {    let db = Database::connect("postgres://user:pass@localhost/db").await.unwrap();        // Inserción    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();        // Selección de todos    let users: Vec<Model> = Entity::find().all(&db).await.unwrap();}

3. SQLx — no es un ORM, sino un controlador SQL asíncrono con verificación en tiempo de compilación

SQLx ocupa una posición intermedia: no es un ORM completo, pero proporciona herramientas potentes para trabajar con SQL con verificación de consultas en tiempo de compilación. Es ideal para quienes prefieren escribir SQL puro, pero quieren evitar errores.

Características principales:

Asíncrono (Tokio, async-std)
Verificación de consultas SQL en tiempo de compilación mediante la macro sqlx::query!
Soporte para PostgreSQL, MySQL, SQLite, MSSQL
Ligero, sin magia de ORM