Diesel vs SQLx in Raw and ORM Modes

Diesel vs SQLx in Raw and ORM Modes

Rust developers often face a choice between Diesel and SQLx for database interactions. Diesel is a full-featured ORM (Object-Relational Mapper), while SQLx is a compile-time checked, async-friendly query library. Here's a quick comparison of their performance and usage in raw and ORM modes.

---

Performance Comparison

Mode	Diesel	SQLx
Pure ORM Mode	Slightly faster due to optimizations.	Slower compared to Diesel in ORM-like use.
Query Builder	~50% slower than SQLx in raw queries.	Faster, especially for raw SQL execution.

---

Code Examples

Diesel in ORM Mode

Using Diesel's schema and ORM for managing database queries.

use diesel::prelude::*;
use diesel::pg::PgConnection;
use crate::schema::users;

#[derive(Queryable, Insertable)]
#[table_name = "users"]
struct User {
    id: i32,
    name: String,
}

fn fetch_users(conn: &PgConnection) -> Vec<User> {
    use crate::schema::users::dsl::*;
    users.load::<User>(conn).expect("Error loading users")
}

Diesel in Raw Query Mode

Bypassing Diesel's query builder for raw SQL queries.

use diesel::sql_query;
use diesel::pg::PgConnection;
use diesel::RunQueryDsl;

fn fetch_users_raw(conn: &PgConnection) {
    let query = "SELECT id, name FROM users;";
    let results = sql_query(query).load::<(i32, String)>(conn).expect("Query failed");
    println!("{:?}", results);
}

SQLx in Raw Mode

Direct SQL execution using SQLx's async API.

use sqlx::{PgPool, Row};

async fn fetch_users(pool: &PgPool) {
    let rows = sqlx::query("SELECT id, name FROM users;")
        .fetch_all(pool)
        .await
        .expect("Query failed");

    for row in rows {
        let id: i32 = row.get("id");
        let name: String = row.get("name");
        println!("{} - {}", id, name);
    }
}

SQLx in ORM-Like Mode

Using SQLx structs to map query results.

use sqlx::FromRow;

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

async fn fetch_users(pool: &PgPool) {
    let users: Vec<User> = sqlx::query_as!(User, "SELECT id, name FROM users;")
        .fetch_all(pool)
        .await
        .expect("Query failed");
    println!("{:?}", users);
}

---

Key Takeaways

• Diesel excels in ORM mode for its type safety and compile-time guarantees but slows down with its query builder.
• SQLx is faster for raw queries and supports async natively, making it ideal for modern web applications.

For a high-performance, async-friendly environment, SQLx in raw mode is a solid choice. However, if compile-time safety and ease of schema management matter more, Diesel ORM is unbeatable.