ORM para Rust: comparación y ejemplos de Diesel, SeaORM, SQLx

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

El ecosistema de Rust ofrece varias soluciones potentes para trabajar con bases de datos. En este artículo compararemos en detalle tres enfoques principales: Diesel (ORM síncrono, compilable), SeaORM (asíncrono, flexible) y SQLx (minimalista, con verificación de consultas en tiempo de compilación). Aprenderá qué herramienta elegir para tareas específicas y verá ejemplos de código funcionales.

1. Diesel — ORM síncrono probado

Diesel es el ORM más maduro para Rust. Su principal característica es la seguridad de tipos en tiempo de compilación. Todas las consultas SQL se verifican durante la compilación, lo que elimina toda una clase de errores. Funciona solo de forma síncrona, pero con tokio se puede organizar un pool de conexiones.

Ejemplo de uso de Diesel:

// models.rs#[derive(Queryable, Insertable)]#[table_name = "users"]pub struct User {    pub id: i32,    pub name: String,    pub email: String,}

// main.rsuse diesel::prelude::*;use diesel::dsl::insert_into;

fn main() {    let conn = PgConnection::establish("postgres://user:pass@localhost/db")        .expect("Database connection failed");

    let new_user = User {        id: 0,        name: "Alice".into(),        email: "alice@example.com".into(),    };

    let inserted = insert_into(users::table)        .values(&new_user)        .get_result::<User>(&conn)        .expect("Insert failed");

    println!("Created user: {}", inserted.name);}

Ventajas: máximo rendimiento, tipado estricto, migraciones integradas.

Desventajas: síncrono, configuración compleja, no soporta async de forma nativa.

2. SeaORM — asíncrono y flexible

SeaORM es un ORM asíncrono moderno, construido sobre sqlx. Soporta tokio y async-std. Ofrece una API rica para CRUD, relaciones (uno a uno, uno a muchos) y migraciones. Ideal para aplicaciones web con Actix o Axum.

Ejemplo con SeaORM:

use sea_orm::*;use sea_orm::entity::prelude::*;

#[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 {}

// Usoasync fn create_user(db: &DatabaseConnection) -> Result<(), DbErr> {    let user = ActiveModel {        name: Set("Bob".to_owned()),        email: Set("bob@example.com".to_owned()),        ..Default::default()    };    let result = user.insert(db).await?;    println!("User created with id: {}", result.id);    Ok(())}

Ventajas: async completo, soporte para PostgreSQL, MySQL, SQLite, migraciones simples.

Desventajas: más lento que Diesel en pruebas sintéticas, más dependencias.

3. SQLx — ligero y seguro

SQLx no es un ORM en el sentido clásico, sino un controlador SQL asíncrono con verificación de consultas en tiempo de compilación. Usted escribe SQL puro, y SQLx verifica su sintaxis y tipos de argumentos. Soporta PostgreSQL, MySQL, SQLite. Es una excelente opción si prefiere tener control total sobre las consultas.

Ejemplo de SQLx:

use sqlx::postgres::PgPool;

#[derive(sqlx::FromRow)]struct User {    id: i32,    name: String,    email: String,}

#[tokio::main]async fn main() -> Result<(), sqlx::Error> {    let pool = PgPool::connect("postgres://user:pass@localhost/db").await?;

    let user = sqlx::query_as::<_, User>(        "SELECT id, name, email FROM users WHERE email = $1"