Rust ORM with transparent mapping

community
1

does Rust have a Python-like ORM like sqlalchemy with imperative mapping or C# EF Core? In these ORMs, you can describe your pure domain entities that will not know about the database in any way, you can use them in your program without knowing anything about the database. Is there such a thing in Rust?

Everything I see requires me to specify special macros in domain entities related to the database in one way or another, changing the attribute of a database entity requires me to use library classes, for example SeaORM:

pear.name = Set("Sweet pear".to_owned());

In python sqlalchemy (with imperative mapping) i just do:

pear.name = "smth"

On my domain entity (just usual python class)

I just want to keep my business logic clean and don't want it to know about database or ORM related details. I want to separately describe my business entities and separate structures that directly represent database tables, and then "link" them through ORM capabilities, so in my business logic I can work with my business entities and the changes will display in database (UoW pattern)

In fact, I could even put up with special macros on structures if the library allowed me to continue working with my entities as with ordinary structures in Rust, without thinking about classes from ORM.

2

Rust is a statically typed language. You'll need a way to map your domain models to something that the ORM understands in one way or another.

If you don't want your domain types to get polluted with database-related details such as ORM macros or types, you can create a type that interacts with the ORM, and then convert your domain into that type using the Fromand Ìnto traits.

2 Likes
3

C# is also a static-typed language but look at EF core

4

Most of that uses reflection which Rust doesn't support directly

5

I'm not sure if there is any crate about it but I think it's possible with serde like things but feels like it's a bit code mess for Rust. Since Rust is very strict about data.

In that kind of design probably every data field will return result data type since we don't know if the field even there or not.

6

Crates like diesel (and sea-orm) allow you to describe your columns from a struct and macro attributes, and you can create queries by using them without much boilerplate. This is from the diesel crate:

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

let new_users = vec![
    NewUser { name: "Sean", hair_color: Some("Black") },
    NewUser { name: "Gordon", hair_color: None },
];

insert_into(users)
    .values(&new_users)
    .execute(&mut connection);

or

update(users.filter(email.like("%@spammer.com")))
    .set(banned.eq(true))
    .execute(&mut connection)

The code you show about sea-orm seems to use Set to indicate what to do with the columns, which looks a little more verbose, but I don't know much about it.

1 Like
7

...unless you use dynamic at which point it's not at all.

8

Without these newtypes, you would lose compile time verified queries. They don't just exist to make your code more difficult. Sqlalchemy and EF give you no such validation.

9

you can try Rbatis 4.6 - High-Performance Rust ORM Framework Upgrade
this is allow python like query ORM(see doc).
just like example:

pub struct User{
    pub delete_flag:i32,
    pub name:String
}

#[py_sql(
    "`select * from user where delete_flag = 0`
                  if name != '':
                    ` and name=#{name}`"
)]
async fn py_select(rb: & dyn Executor, name: &str) -> Result<Vec<User>, Error> {
    impled!()
}