diesel VS prisma-client-rust

Tauri's backend is in Rust, so I always thought the only way to use sqlite ORM in a Tauri app is with projects like diesel or prisma-client-rust, which could be hard because they are in rust. What is even harder is sqlite db encryption. Both of the 2 ORMs don't support cipher encryption, thus I had to write raw sql queries in kunkun Example Maintaining raw sql queries is a nightmare to me, especially when it comes to schema migration. I have to rely on thorough testing to make sure everything is correct. There is no type checking.

I think you are talking past each others. Preventing N+1 by doing lazy fetching and having synchronous / asynchronous API are orthogonal issues. Async API must not block the thread/event loop when the data loading is being done.

Diesel hasn't been providing an async API for reason told in this thread: https://github.com/diesel-rs/diesel/issues/399

The situation might change some day though, once async support in the core language and surrounding ecosystem gets stronger.

I would kinda expect REST framework to be able to generate Swagger (aka OpenAPI) definitions out of the box. That's one of the killer features if FastAPI in my opinion.

Also, I don't really understand what is the reason for creating your own ORM instead of integrating with, let's say diesel.rs [0] and what is the reason for inventing your own template language instead of just picking own of the most popular existing template engines [1].

Other than that this project looks really interesting and I will definitely keep an eye on it.

[0] https://diesel.rs/

[1] https://crates.io/categories/template-engine

> sqlx — a compile time, type safe SQL wrapper that runs your queries against a real DB

SQLx seems like end game stuff at first glance, but after trying it out for a while I eventually decided that it wasn't for me. Writing dynamic/conditional queries just sucks and there isn't any good solution. On the DX side, completion, formatting/linting, highlighting is also non-existent.

I eventually settled on [diesel][0] (a query builder-ish ORM) and I'm loving it so far. Its [performance][1] crushes every other SQL libraries, including SQLx (very counter-intuitive, huh?). It's technically an ORM, but the query builder is very flexible and you can also extend it with your own traits. It got its warts, but it's the most tolerable SQL rust library I've found so far.

[0]: https://diesel.rs

Diesel has support for MySQL, Sqlite and Postgres which can easily execute raw queries

https://github.com/diesel-rs/diesel

Here is another thing worth sharing. Database integration tests on Bazel used to be difficult. Ultimately I've found an elegant solution:

https://github.com/diesel-rs/diesel/blob/master/examples/pos...

The parallel testing with dangling transactions isn't Diesel or Postgres specific. You can do the same with pure SQL and any relational DB that supports transactions.

For CI, BuildBuddy can spin up Docker in a remote execution host, then you write a custom util that tests if the DB container is already running and if not starts one, out that in a test and then let Bazel execute all integration tests in parallel. For some weird reasons, all tests have to be in one file per insolated remote execution host, so I created one per table.

Incremental builds that compile, tests, build and publish images usually complete in about one minute. That's thanks to the 80 Core BuildBuddy cluster with remote cache.

GitHub took about an hour back in April when the repo was half in size.

There is real gain in terms of developer velocity.

7. Diesel

Both seem nice. However, both of them rely very heavily on prepared statements. Unfortunately, using prepared statements is a no-go when you use connection poolers like pgbouncer, or in my case AWS RDS proxy. A discussion in Diesel indicates that disel is not going to provide any support for disabling prepared stements (https://github.com/diesel-rs/diesel/discussions/3575), and a discussion on sqlx hints that disabling prepared statements is possible, but I haven't found any documentation or examples for it.

In addition we are experimenting with prebuild versions of diesel-cli that can be installed directly. We have a set of prebuilt binaries here. We are interested in feedback about how the provided binaries work on your platform.

First of all thanks for making this great tool. As it happens I currently toy around with using it for diesel-cli releases. See the WIP PR here. I think diesel-cli is a good example of a tool that depends on system libraries as it needs to link native database drivers, so this new release is welcome. Defining the dependencies seems to allow easily building things on x86_64-unknown-linux-gnu and x86_64-apple-darwin. It seems to pick up everything in the right way there.

Tauri's backend is in Rust, so I always thought the only way to use sqlite ORM in a Tauri app is with projects like diesel or prisma-client-rust, which could be hard because they are in rust. What is even harder is sqlite db encryption. Both of the 2 ORMs don't support cipher encryption, thus I had to write raw sql queries in kunkun Example Maintaining raw sql queries is a nightmare to me, especially when it comes to schema migration. I have to rely on thorough testing to make sure everything is correct. There is no type checking.

I build simple rust axum api server with Prisma client rust. This is my something done with rust and I really enjoyed rust!

Prisma Client Rust. If you come from the JS/TS world this fits right in. It's halfway between a full ORM and SQL(x), so I prefer it.

Wut, Prisma works with Rust?! Is this what you're referring to? : https://github.com/Brendonovich/prisma-client-rust

There's Prisma Client Rust if you want a fully fledged ORM!

Damn, I use Prisma, it's a good way to have a unified database schema for which you can generate code in any language you want. It was very useful for converting a TypeScript project to a Rust one, I use prisma-client-rust in particular.

https://github.com/Brendonovich/prisma-client-rust

I also come from the NodeJS world where I used Prisma as an ORM / query builder. Turns out since the schema is language agnostic, anyone can make clients for it for any language, including Rust. I made a simple example which combines Prisma Client Rust, Actix Web, and Async GraphQL together, fairly straightforward to make.