#database #sql #async #await


🧰 The Rust SQL Toolkit. An async, pure Rust SQL crate featuring compile-time checked queries without a DSL. Supports PostgreSQL, MySQL, and SQLite.

13 releases

✓ Uses Rust 2018 edition

new 0.3.0-alpha.2 Mar 25, 2020
0.3.0-alpha.1 Mar 19, 2020
0.2.6 Mar 10, 2020
0.2.5 Feb 1, 2020
0.1.0 Jun 6, 2019

#8 in Database interfaces

Download history 2/week @ 2019-12-02 8/week @ 2019-12-09 24/week @ 2019-12-23 47/week @ 2019-12-30 91/week @ 2020-01-06 334/week @ 2020-01-13 193/week @ 2020-01-20 378/week @ 2020-01-27 295/week @ 2020-02-03 222/week @ 2020-02-10 268/week @ 2020-02-17 280/week @ 2020-02-24 174/week @ 2020-03-02 490/week @ 2020-03-09 601/week @ 2020-03-16

1,243 downloads per month
Used in 5 crates


12K SLoC


🧰 The Rust SQL Toolkit

Built with ❤️ by The LaunchBadge team

SQLx is an async, pure Rust SQL crate featuring compile-time checked queries without a DSL.

  • Truly Asynchronous. Built from the ground-up using async/await for maximum concurrency.

  • Type-safe SQL (if you want it) without DSLs. Use the query!() macro to check your SQL and bind parameters at compile time. (You can still use dynamic SQL queries if you like.)

  • Pure Rust. The Postgres and MySQL/MariaDB drivers are written in pure Rust using zero unsafe code.

  • Runtime Agnostic. Works on async-std or tokio with the runtime-async-std or runtime-tokio cargo feature flag.



# Cargo.toml
sqlx = "0.2"


# Cargo.toml
sqlx = { version = "0.2", default-features = false, features = [ "runtime-tokio", "macros" ] }

Cargo Feature Flags

  • runtime-async-std (on by default): Use the async-std runtime.

  • runtime-tokio: Use the tokio runtime. Mutually exclusive with the runtime-async-std feature.

  • postgres: Add support for the Postgres database server.

  • mysql: Add support for the MySQL (and MariaDB) database server.

  • sqlite: Add support for the self-contained SQLite database engine.

  • uuid: Add support for UUID (in Postgres).

  • chrono: Add support for date and time types from chrono.

  • time: Add support for date and time types from time crate (alternative to chrono, prefered by query! macro, if both enabled)

  • tls: Add support for TLS connections.



It is a very good idea to always create a connection pool at the beginning of your application and then share that.

// Postgres
let pool = sqlx::PgPool::new("postgres://localhost/database").await?;


The sqlx::query function provides general-purpose prepared statement execution. The result is an implementation of the Row trait. Values can be efficiently accessed by index or name.

let row = sqlx::query("SELECT is_active FROM users WHERE id = ?")
    .fetch_one(&mut &pool)
let is_active: bool = row.get("is_active");


The sqlx::query! macro prepares the SQL query at compile time and interprets the result in order to constrain input types and infer output types. The result of query! is an anonymous struct (or named tuple).

let countries = sqlx::query!(
        "SELECT country, COUNT(*) FROM users GROUP BY country WHERE organization = ?", 
    .fetch(&mut &pool) // -> impl Stream<Item = { country: String, count: i64 }>
    .map_ok(|rec| (rec.country, rec.count))
    .try_collect::<HashMap<_>>() // -> HashMap<String, i64>

For this mode, the DATABASE_URL environment variable must be set at build time to a database which it can prepare queries against; the database does not have to contain any data but must be the same kind (MySQL, Postgres, etc.) and have the same schema as the database you will be connecting to at runtime. For convenience, you can use a .env file to set DATABASE_URL so that you don't have to pass it every time:


See the beginnings of a RealWorld implementation in examples/realworld-postgres.


This crate uses #[forbid(unsafe_code)] to ensure everything is implemented in 100% Safe Rust.


Licensed under either of

at your option.


Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.


~110K SLoC