Cherry 🍒

Cherry is a Rust async ORM, build on top of SQLx, support for MySQL, PostgreSQL and SQLite. It's designed to be easy to use.

required features

Database

At least one of the features must be enabled: sqlite, postgres, mysql.

Async runtime

• async-std: runtime-async-std-native-tls, runtime-async-std-rustls.
• tokio: runtime-tokio-native-tls, runtime-tokio-rustls.
• actix: runtime-actix-native-tls, runtime-actix-rustls.

The async runtime is only work for mysql and postgres.

For example, assume you pick sqlite, mysql and async-std runtime runtime-async-std-rustls, the toml dependency should look like:

[dependencies]
cherry = { version = "0.4.0", features = ["sqlite", "mysql", "runtime-async-std-rustls"] }

Example

use cherry::{Cherry, QueryExecutor};
use cherry::clause::Where;
use cherry::sqlite::SqlitePool;
// use cherry::mysql::MySqlPool;

#[derive(Cherry)]
struct User {
    id: u32,
    name: String,
}

async fn example() {
    let pool = SqlitePool::connect("sqlite::memory:").await.unwrap();
    // let pool = MySqlPool::connect("mysql://username:password@localhost/test").await.unwrap();

    let user = User { id: 100, name: "Joe" };
    let result = user.insert().execute(&pool).await.unwrap();
    assert_eq!(1, result.rows_affected);

    let result = User::select().and_eq("id", &user.id).one(&pool).await.unwrap();
    assert!(result.is_some());
    assert_eq!(user.name, result.unwrap().name);
}

Insert

// Insert one
let user = User { id: 100, name: "Joe" };
let result = user.insert().execute(&pool).await?;
assert_eq!(1, result.rows_affected);

// Insert multiple
let users = vec![ /*...*/];
User::insert_bulk(&users).execute(&pool).await?;

// Insert ignore on conflict
User::insert_bulk(&users).ignore_on_conflict().execute(&pool).await?;

// Insert update columns if the column "id" conflict (valid for sqlite and postgres)
User::insert_bulk(&users).update_on_conflict().conflict_column("id").set_column("name").set_column("age").execute(&pool).await?;

// Insert or replace if the column "id" conflict (valid for sqlite and mysql, only sqlite can 
specify conflict column)
User::insert_bulk(&users).replace_on_conflict().execute(&pool).await?;

Select

// Select one
let user: Option<User> = User::select().and_eq("id", 100).one(&pool).await?;

// Select in list
let users: Vec<User> = User::select().and_gt("id", 100).all(&pool).await?;

// Select in tuple
let count: Option<(u64,)> = User::select().column_raw("COUNT(*)").tuple(&pool).await?;

// Wrap conditions
// WHERE (id < 100 OR id > 200) AND age > 25
User::select().and(|c| c.or_lt_ref("id", 100).or_gt_ref("id", 200)).and_gt("age", 25).all(&pool)
await?;

Update

User::update().set("name", "Sleepy").and_eq("id", 100).execute(&pool).await?;

Delete

User::delete().and_eq("id", 100).execute(&pool).await?;

Transaction

let mut tx = pool.begin().await?;
User::insert_bulk(&users).execute(&mut tx).await?;
User::update().set("name", "Sleepy").and_eq("id", 100).execute(&mut tx).await?;
tx.commit().await?;

More

Custom table name

// Change the default table name "user" to "people"

#[derive(Cherry)]
#[cherry(table = "people")]
struct User {
    // fields..
}

specify particular database

By default, Cherry will implement all database types for your entity. For some reason, you can specify the particular database type for the entity.

Like this, cherry will implement both "mysql" and "postgres" for the "User" entity:

[dependencies]
cherry = { version = "0.4.0", features = ["postgres", "mysql", "runtime-async-std-rustls"] }

This will implement "mysql" only for the "User" entity:

#[derive(Cherry)]
#[cherry(database = "mysql")]
struct User {
    // fields..
}