website·Indexed 32 days ago
https://prisma.brendonovich.devA Rust-specific client for using Prisma in Rust projects. Documentation covers installation, setup, and data operations including find, create, update, delete, and upsert queries. It also provides guidance on advanced features such as pagination, relational fetching, transactions, batching, raw queries, mocking, and integration with rspc.
PrismaClient::_migrate_deploy to apply all pending migrations that were previously generated via the Prisma CLI. This should be used after schema changes have been finalized and migrations have been created using migrate dev.raw! macro, use the Raw struct. Create a Raw instance by calling Raw::new(query, values), where query is the SQL string and values is a Vec<PrismaValue>.The Prisma Client requires the tokio async runtime. Use PrismaClient::_builder().build().await to instantiate the client.
If you need to connect to a specific database dynamically (e.g., for desktop apps where environment variables are impractical), use the .with_url() method on the builder.
// Stops the client from outputting a huge number of warnings during compilation.
#[allow(warnings, unused)]
mod prisma;
use prisma::PrismaClient;
use prisma_client_rust::NewClientError;
#[tokio::main]
async fn main() {
let client: Result<PrismaClient, NewClientError> = PrismaClient::_builder().build().await;
}.cursor() method to start pagination from a specific record. The cursor method requires a unique filter as its argument. This is often used in combination with order_by for efficient pagination.use prisma::post;
let posts: Vec<post::Data> = client
.post()
.find_many(vec![])
.cursor(post::id::equals("abc".to_string()))
.exec()
.await?;client._transaction().begin(). This returns a tuple containing a TransactionManager and a dedicated PrismaClient. To finalize the transaction, call tx.commit(client) or tx.rollback(client). Note that these methods consume the transaction-specific client to prevent its use after the transaction ends.let (tx, client) = client
._transaction()
.begin()
.await?;
// ... perform operations using the transaction client ...
tx.commit(client).await?;
// or
tx.rollback(client).await?;find_unique or find_many. Instead, use the dedicated .update(), .delete(), .update_many(), and .delete_many() methods, passing the filter as the first argument.// Single record: Before
client.user().find_unique(user::id::equals(0)).update(vec![])
// Single record: After
client.user().update(user::id::equals(0), vec![])
// Multiple records: Before
client.user().find_many(vec![user::name::contains("Brendan".to_string())]).delete()
// Multiple records: After
client.user().delete_many(vec![user::name::contains("Brendan".to_string())])snake_case naming conventions. These modules provide functions to construct modifiers for filtering queries. To filter, pass these modifiers into the query method (e.g., find_many).use prisma::post;
client
.post()
.find_many(vec![
// Pattern: model::field::method()
post::title::equals("Test".to_string())
])
.exec()
.await;Relations can be modified using connect and disconnect within update queries for single records.
Caveat: Using connect or disconnect within update_many will cause the query to return an error. To update relations for multiple records, you must set the relation's scalar fields (foreign keys) directly.
// Single record: Disconnecting a relation
use prisma::{comment, post};
let updated_comment: comment::Data = client
.post()
.update(
comment::id::equals("id".to_string()),
vec![comment::post::disconnect()]
)
.exec()
.await?;
// Many records: Updating relation via scalar field (foreign key)
let updated_comments_count: i64 = client
.post()
.update_many(
vec![comment::post::is(
post::id::equals("id".to_string())
)],
vec![comment::post_id::set("post".to_string())]
)
.exec()
.await?;Data struct and a helper function. This allows you to use the selection's type in function signatures (e.g., as a return type).// Generates mod post_only_title { pub struct Data { title: String }, pub fn select() }
post::select!(post_only_title {
title
})
async fn do_query() -> Vec<post_only_title::Data> {
client
.post()
.find_many(vec![])
.select(post_only_title::select())
.exec()
.await
.unwrap()
}client._transaction().run() to execute a series of queries within a transaction closure. The closure must return an async move block that accepts a dedicated PrismaClient instance and returns a Result. If the closure returns Ok, the transaction commits; if it returns Err, it rolls back.let (user, post) = client
._transaction()
.run(|client| async move {
let user = client
.user()
.create("brendan".to_string(), vec![])
.exec()
.await?;
client
.post()
.create(
"test".to_string(),
true,
vec![post::author::connect(
user::id::equals(user.id.clone()))],
),
.exec()
.await
// if query succeeds, return user + post from transaction
.map(|post| (user, post))
})
.await?;