Run any Skill in Manus with one click

Get Started

diesel-orm

Stars82

Forks9

UpdatedMarch 8, 2026 at 06:14

Type-safe Rust ORM with compile-time query validation.

Installation

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

Run Skill in Manus

Source

A/.dotfiles

View GitHub Repository View Creator Repositories

Download

Run Skill in Manus

Related occupationsSOC

Based on SOC occupation classification

Software DevelopersComputer and Mathematical Occupations·SOC 15-1252

SKILL.md

readonly

name	Diesel ORM
description	Type-safe Rust ORM with compile-time query validation.
metadata	{"labels":["rust","diesel","orm","database","postgresql"],"triggers":{"files":["**/schema.rs","diesel.toml"],"keywords":["diesel","Queryable","Insertable","table"]}}

Diesel ORM Standards

Schema Definition

// Generated by diesel migration run
// src/schema.rs
diesel::table! {
    users (id) {
        id -> Int4,
        name -> Varchar,
        email -> Varchar,
        created_at -> Timestamp,
    }
}

Model Structs

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

#[derive(Queryable, Selectable, Debug)]
#[diesel(table_name = users)]
pub struct User {
    pub id: i32,
    pub name: String,
    pub email: String,
    pub created_at: NaiveDateTime,
}

#[derive(Insertable)]
#[diesel(table_name = users)]
pub struct NewUser<'a> {
    pub name: &'a str,
    pub email: &'a str,
}

#[derive(AsChangeset)]
#[diesel(table_name = users)]
pub struct UpdateUser<'a> {
    pub name: Option<&'a str>,
    pub email: Option<&'a str>,
}

Connection Pool

use diesel::pg::PgConnection;
use diesel::r2d2::{Pool, ConnectionManager};

type DbPool = Pool<ConnectionManager<PgConnection>>;

fn establish_pool(database_url: &str) -> DbPool {
    let manager = ConnectionManager::<PgConnection>::new(database_url);
    Pool::builder()
        .max_size(15)
        .build(manager)
        .expect("Failed to create pool")
}

CRUD Operations

use diesel::prelude::*;
use crate::schema::users::dsl::*;

// Create
fn create_user(conn: &mut PgConnection, new_user: &NewUser) -> QueryResult<User> {
    diesel::insert_into(users)
        .values(new_user)
        .get_result(conn)
}

// Read
fn find_user(conn: &mut PgConnection, user_id: i32) -> QueryResult<User> {
    users.find(user_id).first(conn)
}

fn list_users(conn: &mut PgConnection) -> QueryResult<Vec<User>> {
    users.load(conn)
}

// Update
fn update_user(conn: &mut PgConnection, user_id: i32, changes: &UpdateUser) -> QueryResult<User> {
    diesel::update(users.find(user_id))
        .set(changes)
        .get_result(conn)
}

// Delete
fn delete_user(conn: &mut PgConnection, user_id: i32) -> QueryResult<usize> {
    diesel::delete(users.find(user_id)).execute(conn)
}

Query Building

// Filtering
let active_users = users
    .filter(active.eq(true))
    .filter(created_at.gt(cutoff_date))
    .load::<User>(conn)?;

// Ordering and pagination
let page = users
    .order(created_at.desc())
    .limit(10)
    .offset(20)
    .load::<User>(conn)?;

// Select specific columns
let emails: Vec<String> = users
    .select(email)
    .load(conn)?;

// Joins
let user_posts = users
    .inner_join(posts::table)
    .select((users::name, posts::title))
    .load::<(String, String)>(conn)?;

Transactions

conn.transaction(|conn| {
    diesel::insert_into(users)
        .values(&new_user)
        .execute(conn)?;

    diesel::insert_into(audit_log)
        .values(&log_entry)
        .execute(conn)?;

    Ok(())
})

Migrations

# Create migration
diesel migration generate create_users

# Run pending migrations
diesel migration run

# Revert last migration
diesel migration revert

# Redo last migration
diesel migration redo

Best Practices

Schema sync: Run diesel migration run before compile
Pool sizing: Match to expected concurrent connections
Derive macros: Use Queryable for reads, Insertable for writes
Nullable: Use Option<T> for nullable columns
Raw SQL: Use sql_query() for complex queries when needed

More from this repository

same repository

scrum-grooming

A/.dotfiles

Create a structured implementation plan for a feature request. Covers architecture, system design, module design, pattern selection, and milestone-based task planning with DoD. Use when the user describes a new feature, significant change, or multi-step implementation task.

2026-04-1582

scrum-implement

A/.dotfiles

Execute an implementation plan milestone-by-milestone. Reads the plan, reviews lessons, then implements tasks using agents for parallelizable work. Invoke with /scrum-implement <plan-file-path> or triggered when the user asks to implement/execute a plan.

2026-04-1582

scrum-lessons

A/.dotfiles

Extract lessons from a retrospective and review skills/agents for improvements. Creates lesson files in ~/Claude/lessons/ and suggests concrete changes to scrum skills. Invoke with /scrum-lessons <retrospective-path> or after running /scrum-retro.

2026-04-1582

scrum-retro

A/.dotfiles

Generate a sprint retrospective from a plan file and tech lead feedback. Analyzes what was planned vs what was built, identifies root causes, and produces actionable takeaways. Invoke with /scrum-retro <plan-file-path> or triggered when the user asks to create a retrospective.

2026-04-1582

temporal-python

A/.dotfiles

Temporal Python SDK (`temporalio`) patterns, determinism rules, error handling, and testing. Trigger: When writing Temporal workflows, activities, or workers in Python, or when the user mentions Temporal, durable workflows, or the Python SDK in the context of workflow orchestration. Activated when working on files importing `temporalio`, `@activity.defn`, `@workflow.defn`, in directories named `temporal_app/`, `workflows/`, `activities/`, or when user asks about Temporal concepts, determinism, replay, signals, or activity patterns.

2026-04-1582

setup-python

A/.dotfiles

Set up a new Python/Django project with uv, ruff, basedpyright, pre-commit hooks, Justfile, Docker Compose, and CI. Invoke when starting a new Python project or when asked to set up project tooling.

2026-03-1682

Diesel ORM Standards

Schema Definition

// Generated by diesel migration run // src/schema.rs diesel::table! { users (id) { id -> Int4, name -> Varchar, email -> Varchar, created_at -> Timestamp, } }

Model Structs

use diesel::prelude::*; use crate::schema::users; #[derive(Queryable, Selectable, Debug)] #[diesel(table_name = users)] pub struct User { pub id: i32, pub name: String, pub email: String, pub created_at: NaiveDateTime, } #[derive(Insertable)] #[diesel(table_name = users)] pub struct NewUser<'a> { pub name: &'a str, pub email: &'a str, } #[derive(AsChangeset)] #[diesel(table_name = users)] pub struct UpdateUser<'a> { pub name: Option<&'a str>, pub email: Option<&'a str>, }

Connection Pool

use diesel::pg::PgConnection; use diesel::r2d2::{Pool, ConnectionManager}; type DbPool = Pool<ConnectionManager<PgConnection>>; fn establish_pool(database_url: &str) -> DbPool { let manager = ConnectionManager::<PgConnection>::new(database_url); Pool::builder() .max_size(15) .build(manager) .expect("Failed to create pool") }

CRUD Operations

use diesel::prelude::*; use crate::schema::users::dsl::*; // Create fn create_user(conn: &mut PgConnection, new_user: &NewUser) -> QueryResult<User> { diesel::insert_into(users) .values(new_user) .get_result(conn) } // Read fn find_user(conn: &mut PgConnection, user_id: i32) -> QueryResult<User> { users.find(user_id).first(conn) } fn list_users(conn: &mut PgConnection) -> QueryResult<Vec<User>> { users.load(conn) } // Update fn update_user(conn: &mut PgConnection, user_id: i32, changes: &UpdateUser) -> QueryResult<User> { diesel::update(users.find(user_id)) .set(changes) .get_result(conn) } // Delete fn delete_user(conn: &mut PgConnection, user_id: i32) -> QueryResult<usize> { diesel::delete(users.find(user_id)).execute(conn) }

Query Building

// Filtering let active_users = users .filter(active.eq(true)) .filter(created_at.gt(cutoff_date)) .load::<User>(conn)?; // Ordering and pagination let page = users .order(created_at.desc()) .limit(10) .offset(20) .load::<User>(conn)?; // Select specific columns let emails: Vec<String> = users .select(email) .load(conn)?; // Joins let user_posts = users .inner_join(posts::table) .select((users::name, posts::title)) .load::<(String, String)>(conn)?;

Transactions

conn.transaction(|conn| { diesel::insert_into(users) .values(&new_user) .execute(conn)?; diesel::insert_into(audit_log) .values(&log_entry) .execute(conn)?; Ok(()) })

Migrations

# Create migration diesel migration generate create_users # Run pending migrations diesel migration run # Revert last migration diesel migration revert # Redo last migration diesel migration redo

Best Practices

Schema sync: Run diesel migration run before compile

Pool sizing: Match to expected concurrent connections

Derive macros: Use Queryable for reads, Insertable for writes

Nullable: Use Option<T> for nullable columns

Raw SQL: Use sql_query() for complex queries when needed