Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/oobot/cherry
A Rust async ORM, support for MySQL, PostgreSQL and SQLite.
https://github.com/oobot/cherry
mysql orm postgresql rust sqlite
Last synced: about 2 months ago
JSON representation
A Rust async ORM, support for MySQL, PostgreSQL and SQLite.
- Host: GitHub
- URL: https://github.com/oobot/cherry
- Owner: oobot
- License: apache-2.0
- Created: 2021-10-23T13:26:58.000Z (about 3 years ago)
- Default Branch: master
- Last Pushed: 2024-04-05T09:44:44.000Z (9 months ago)
- Last Synced: 2024-09-16T13:34:29.308Z (3 months ago)
- Topics: mysql, orm, postgresql, rust, sqlite
- Language: Rust
- Homepage: https://crates.io/crates/cherry
- Size: 191 KB
- Stars: 17
- Watchers: 1
- Forks: 1
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: LICENSE-APACHE
Awesome Lists containing this project
README
# Cherry 🍒
Cherry is a Rust async ORM, build on top of [SQLx](https://github.com/launchbadge/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:
```toml
[dependencies]
cherry = { version = "0.4.0", features = ["sqlite", "mysql", "runtime-async-std-rustls"] }
```
## Example
```rust
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::select().and_eq("id", 100).one(&pool).await?;
// Select in list
let users: Vec = 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:
```toml
[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..
}
```