DEV Community

Cover image for Diesel vs SQLx in Raw and ORM Modes
Yellow Coder
Yellow Coder

Posted on

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")
}
Enter fullscreen mode Exit fullscreen mode
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);
}
Enter fullscreen mode Exit fullscreen mode
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);
    }
}
Enter fullscreen mode Exit fullscreen mode
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);
}
Enter fullscreen mode Exit fullscreen mode

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.

Image of Timescale

Timescale – the developer's data platform for modern apps, built on PostgreSQL

Timescale Cloud is PostgreSQL optimized for speed, scale, and performance. Over 3 million IoT, AI, crypto, and dev tool apps are powered by Timescale. Try it free today! No credit card required.

Try free

Top comments (0)

Image of Docusign

🛠️ Bring your solution into Docusign. Reach over 1.6M customers.

Docusign is now extensible. Overcome challenges with disconnected products and inaccessible data by bringing your solutions into Docusign and publishing to 1.6M customers in the App Center.

Learn more

👋 Kindness is contagious

Immerse yourself in a wealth of knowledge with this piece, supported by the inclusive DEV Community—every developer, no matter where they are in their journey, is invited to contribute to our collective wisdom.

A simple “thank you” goes a long way—express your gratitude below in the comments!

Gathering insights enriches our journey on DEV and fortifies our community ties. Did you find this article valuable? Taking a moment to thank the author can have a significant impact.

Okay