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.

Do your career a big favor. Join DEV. (The website you're on right now)

It takes one minute, it's free, and is worth it for your career.

Get started

Community matters

Top comments (0)

A Workflow Copilot. Tailored to You.

Pieces.app image

Our desktop app, with its intelligent copilot, streamlines coding by generating snippets, extracting code from screenshots, and accelerating problem-solving.

Read the docs

👋 Kindness is contagious

Dive into an ocean of knowledge with this thought-provoking post, revered deeply within the supportive DEV Community. Developers of all levels are welcome to join and enhance our collective intelligence.

Saying a simple "thank you" can brighten someone's day. Share your gratitude in the comments below!

On DEV, sharing ideas eases our path and fortifies our community connections. Found this helpful? Sending a quick thanks to the author can be profoundly valued.

Okay