Menu
Integrate databases with Salvo using SQLx, Diesel, SeaORM, or other ORMs. Use for persistent data storage and database operations.
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.
Based on SOC occupation classification
Guide for using RBatis v4 Rust ORM framework. Use when implementing database CRUD operations, writing dynamic SQL with py_sql or html_sql macros, configuring database connections, managing transactions, implementing interceptors, syncing table structures, or integrating RBatis into Genies microservices. Also use when the user asks about RBatis usage patterns, query building, or database operations in Rust.
Genies 前后端接口规范。Use when designing API contracts, defining field naming conventions, date/time formats, response models, pagination, error handling, or ID strategies between Genies backend and frontend (Web/Android/OHOS).
Guide for using flyway-rs database migration framework with RBatis. Use when implementing database schema migrations, managing SQL changelog files, configuring migration runners, handling multi-database migrations, or integrating database versioning into Genies microservices.
Guide for developing Rust microservices using Genies framework following Java DDD layering principles. Use when creating new microservices, designing aggregate roots, implementing domain events, organizing service layers, setting up Flyway migrations, or structuring a DDD-based Genies project.
Genies framework unified skill hub. Use when you need to find the right skill for any Genies framework task, including authentication, authorization, caching, configuration, database, DDD microservices, Dapr messaging, macros, K8s deployment, testing, API conventions, gateway proxy, or Salvo web framework features. Also use when the user asks about Genies framework capabilities, asks which skill to use, or wants a quick overview of available Genies skills.
Guide for using the Genies Rust microservice framework with DDD and Dapr. Use when developing with Genies, creating aggregates, domain events, Dapr subscriptions, Casbin field-level permissions, configuration management, or when the user asks about Genies framework usage patterns.
| name | salvo-database |
| description | Integrate databases with Salvo using SQLx, Diesel, SeaORM, or other ORMs. Use for persistent data storage and database operations. |
| version | 0.89.3 |
| tags | ["data","database","sqlx","seaorm","diesel"] |
This skill helps integrate databases with Salvo applications.
[dependencies]
salvo = "0.89.3"
sqlx = { version = "0.8", features = ["runtime-tokio", "postgres", "macros"] }
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
serde = { version = "1", features = ["derive"] }
use salvo::prelude::*;
use salvo::affix_state;
use sqlx::PgPool;
#[tokio::main]
async fn main() {
let pool = PgPool::connect("postgres://user:pass@localhost/db")
.await
.expect("Failed to connect to database");
let router = Router::new()
.hoop(affix_state::inject(pool))
.get(list_users);
let acceptor = TcpListener::new("0.0.0.0:8080").bind().await;
Server::new(acceptor).serve(router).await;
}
use salvo::prelude::*;
use sqlx::{FromRow, PgPool};
use serde::Serialize;
#[derive(FromRow, Serialize)]
struct User {
id: i64,
name: String,
email: String,
}
#[handler]
async fn list_users(depot: &mut Depot) -> Result<Json<Vec<User>>, StatusError> {
let pool = depot.obtain::<PgPool>()
.ok_or_else(|| StatusError::internal_server_error())?;
let users = sqlx::query_as::<_, User>("SELECT id, name, email FROM users")
.fetch_all(pool)
.await
.map_err(|_| StatusError::internal_server_error())?;
Ok(Json(users))
}
#[handler]
async fn create_user(body: JsonBody<CreateUser>, depot: &mut Depot) -> Result<StatusCode, StatusError> {
let pool = depot.obtain::<PgPool>()
.ok_or_else(|| StatusError::internal_server_error())?;
let user = body.into_inner();
sqlx::query("INSERT INTO users (name, email) VALUES ($1, $2)")
.bind(&user.name)
.bind(&user.email)
.execute(pool)
.await
.map_err(|_| StatusError::internal_server_error())?;
Ok(StatusCode::CREATED)
}
#[handler]
async fn get_user(req: &mut Request, depot: &mut Depot) -> Result<Json<User>, StatusError> {
let pool = depot.obtain::<PgPool>()
.ok_or_else(|| StatusError::internal_server_error())?;
let id = req.param::<i64>("id")
.ok_or_else(|| StatusError::bad_request())?;
let user = sqlx::query_as::<_, User>("SELECT id, name, email FROM users WHERE id = $1")
.bind(id)
.fetch_optional(pool)
.await
.map_err(|_| StatusError::internal_server_error())?
.ok_or_else(|| StatusError::not_found())?;
Ok(Json(user))
}
[dependencies]
salvo = "0.89.3"
sea-orm = { version = "1.0", features = ["sqlx-postgres", "runtime-tokio-native-tls", "macros"] }
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
use salvo::prelude::*;
use salvo::affix_state;
use sea_orm::{Database, DatabaseConnection};
#[tokio::main]
async fn main() {
let db = Database::connect("postgres://user:pass@localhost/db")
.await
.expect("Failed to connect");
let router = Router::new()
.hoop(affix_state::inject(db))
.get(list_users);
let acceptor = TcpListener::new("0.0.0.0:8080").bind().await;
Server::new(acceptor).serve(router).await;
}
use salvo::prelude::*;
use sea_orm::*;
#[handler]
async fn list_users(depot: &mut Depot) -> Result<Json<Vec<user::Model>>, StatusError> {
let db = depot.obtain::<DatabaseConnection>()
.ok_or_else(|| StatusError::internal_server_error())?;
let users = user::Entity::find()
.all(db)
.await
.map_err(|_| StatusError::internal_server_error())?;
Ok(Json(users))
}
#[handler]
async fn create_user(body: JsonBody<CreateUser>, depot: &mut Depot) -> Result<StatusCode, StatusError> {
let db = depot.obtain::<DatabaseConnection>()
.ok_or_else(|| StatusError::internal_server_error())?;
let data = body.into_inner();
let user = user::ActiveModel {
name: Set(data.name),
email: Set(data.email),
..Default::default()
};
user.insert(db).await
.map_err(|_| StatusError::internal_server_error())?;
Ok(StatusCode::CREATED)
}
[dependencies]
salvo = "0.89.3"
diesel = { version = "2.2", features = ["postgres", "r2d2"] }
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
use salvo::prelude::*;
use salvo::affix_state;
use diesel::r2d2::{self, ConnectionManager};
use diesel::PgConnection;
type DbPool = r2d2::Pool<ConnectionManager<PgConnection>>;
#[tokio::main]
async fn main() {
let manager = ConnectionManager::<PgConnection>::new("postgres://user:pass@localhost/db");
let pool = r2d2::Pool::builder()
.build(manager)
.expect("Failed to create pool");
let router = Router::new()
.hoop(affix_state::inject(pool))
.get(list_users);
let acceptor = TcpListener::new("0.0.0.0:8080").bind().await;
Server::new(acceptor).serve(router).await;
}
use salvo::prelude::*;
use diesel::prelude::*;
#[handler]
async fn list_users(depot: &mut Depot) -> Result<Json<Vec<User>>, StatusError> {
let pool = depot.obtain::<DbPool>()
.ok_or_else(|| StatusError::internal_server_error())?
.clone();
let users = tokio::task::spawn_blocking(move || {
let mut conn = pool.get().map_err(|_| ())?;
use crate::schema::users::dsl::*;
users.load::<User>(&mut conn).map_err(|_| ())
})
.await
.map_err(|_| StatusError::internal_server_error())?
.map_err(|_| StatusError::internal_server_error())?;
Ok(Json(users))
}
#[handler]
async fn transfer_funds(body: JsonBody<Transfer>, depot: &mut Depot) -> Result<StatusCode, StatusError> {
let pool = depot.obtain::<PgPool>()
.ok_or_else(|| StatusError::internal_server_error())?;
let transfer = body.into_inner();
let mut tx = pool.begin().await
.map_err(|_| StatusError::internal_server_error())?;
sqlx::query("UPDATE accounts SET balance = balance - $1 WHERE id = $2")
.bind(transfer.amount)
.bind(transfer.from_account)
.execute(&mut *tx)
.await
.map_err(|_| StatusError::internal_server_error())?;
sqlx::query("UPDATE accounts SET balance = balance + $1 WHERE id = $2")
.bind(transfer.amount)
.bind(transfer.to_account)
.execute(&mut *tx)
.await
.map_err(|_| StatusError::internal_server_error())?;
tx.commit().await
.map_err(|_| StatusError::internal_server_error())?;
Ok(StatusCode::OK)
}
use salvo::prelude::*;
use sqlx::{FromRow, PgPool};
use serde::{Deserialize, Serialize};
#[derive(FromRow, Serialize)]
struct User {
id: i64,
name: String,
email: String,
}
#[derive(Deserialize)]
struct CreateUser {
name: String,
email: String,
}
#[handler]
async fn list_users(depot: &mut Depot) -> Result<Json<Vec<User>>, StatusError> {
let pool = depot.obtain::<PgPool>()
.ok_or_else(|| StatusError::internal_server_error())?;
let users = sqlx::query_as::<_, User>("SELECT id, name, email FROM users")
.fetch_all(pool)
.await
.map_err(|_| StatusError::internal_server_error())?;
Ok(Json(users))
}
#[handler]
async fn create_user(body: JsonBody<CreateUser>, depot: &mut Depot) -> Result<StatusCode, StatusError> {
let pool = depot.obtain::<PgPool>()
.ok_or_else(|| StatusError::internal_server_error())?;
let user = body.into_inner();
sqlx::query("INSERT INTO users (name, email) VALUES ($1, $2)")
.bind(&user.name)
.bind(&user.email)
.execute(pool)
.await
.map_err(|_| StatusError::internal_server_error())?;
Ok(StatusCode::CREATED)
}
#[tokio::main]
async fn main() {
let pool = PgPool::connect("postgres://user:pass@localhost/db")
.await
.expect("Failed to connect");
let router = Router::new()
.hoop(affix_state::inject(pool))
.push(
Router::with_path("users")
.get(list_users)
.post(create_user)
);
let acceptor = TcpListener::new("0.0.0.0:8080").bind().await;
Server::new(acceptor).serve(router).await;
}
affix_state::inject() for dependency injectiondepot.obtain::<T>() to retrieve injected statespawn_blocking for sync database operations (Diesel)