rust-backend-database
Implements database integration patterns for Rust backends using SQLx and SeaORM. Use when setting up database connections, writing queries, defining entities, managing migrations, or configuring connection pools. Covers compile-time checked SQL, ORM patterns, and N+1 prevention.
When & Why to Use This Skill
This Claude skill provides comprehensive patterns and guidance for integrating databases into Rust backend applications. It leverages SQLx for compile-time verified SQL and SeaORM for complex object-relational mapping, ensuring type safety, efficient connection pooling, and optimized query performance for modern Rust web frameworks.
Use Cases
- Setting up robust and scalable connection pools for high-performance Rust web servers using SQLx.
- Writing type-safe, compile-time checked SQL queries to eliminate runtime database errors and improve code reliability.
- Managing complex database migrations and entity relationships using SeaORM's ActiveRecord patterns for rapid development.
- Implementing atomic transaction logic for multi-step data operations to ensure data integrity in financial or critical systems.
- Optimizing backend performance by identifying and preventing N+1 query problems using advanced data loading techniques.
| name | rust-backend-database |
|---|---|
| description | Implements database integration patterns for Rust backends using SQLx and SeaORM. Use when setting up database connections, writing queries, defining entities, managing migrations, or configuring connection pools. Covers compile-time checked SQL, ORM patterns, and N+1 prevention. |
2. Connection Pooling is Mandatory - Never create individual connections per request.
3. Migrations are Code - Treat migrations as first-class code. Version control, review, test.
4. Choose the Right Tool
- SQLx: Simple to medium complexity, direct SQL control
- SeaORM: Complex relations, dynamic queries, ActiveRecord patterns
use sqlx::postgres::PgPoolOptions;
pub async fn create_pool(database_url: &str) -> Result<PgPool, sqlx::Error> {
PgPoolOptions::new()
.max_connections(10)
.min_connections(2)
.acquire_timeout(Duration::from_secs(3))
.max_lifetime(Duration::from_secs(30 * 60))
.connect(database_url)
.await
}
#[derive(FromRow)]
struct User {
id: i64,
email: String,
name: Option<String>,
}
async fn get_user(pool: &PgPool, id: i64) -> Result<User, sqlx::Error> {
sqlx::query_as!(User, "SELECT id, email, name FROM users WHERE id = $1", id)
.fetch_one(pool)
.await
}
let mut tx = pool.begin().await?;
sqlx::query!("UPDATE accounts SET balance = balance - $1 WHERE id = $2", amount, from_id)
.execute(&mut *tx)
.await?;
sqlx::query!("UPDATE accounts SET balance = balance + $1 WHERE id = $2", amount, to_id)
.execute(&mut *tx)
.await?;
tx.commit().await?;
// GOOD: Smart Entity Loader
let users_with_posts = user::Entity::load()
.filter(user::Column::Active.eq(true))
.with(post::Entity) // 1-N: uses data loader
.with(profile::Entity) // 1-1: uses JOIN
.all(&db)
.await?;