Create Queries

create and create_many allow you to easily create one or many records.

A model's required fields need to be provided as individual arguments to the arguments of create or in a tuple for `create_many', whereas optional fields can be provided in a Vec after all the required fields.

When providing the value of an optional field, it is necessary to wrap the value in a 'field identifier' so that the client knows which field to set. These usually look like model::field::set. This is not required for required fields as they get their own position in the argument list.

Nested creates are not supported yet.

The examples use the following schema:

generator client {
    provider = "cargo prisma"
    output = "src/prisma.rs"
}
 
model Post {
    id        String   @id @default(cuid())
    createdAt DateTime @default(now())
    updatedAt DateTime @updatedAt
    published Boolean
    title     String
    content   String?
    desc      String?
 
    comments Comment[]
}
 
model Comment {
    id        String   @id @default(cuid())
    createdAt DateTime @default(now())
    content   String
 
    post   Post   @relation(fields: [postID], references: [id])
    postID String
}

Create

The following example creates a post and overwrites its autogenerated id field.

use prisma::post;
 
let post: post::Data = client
    .post()
    .create(
        // Required fields are individual arguments.
        // Wrapping their values is not necessary.
        true,
        "what up".to_string(),
        // All other fields can be passed in the last argument
        vec![
            // Generated fields can be overwritten like regular fields
            post::id::set("id".to_string()),
            // Non-required fields require being wrapped in an Option
            post::content::set(Some("content".to_string()))
        ]
    )
    .exec()
    .await?;

Connecting Relations

The connect function of a relation field module can be used to connect new records with existing ones. It takes a single unique filter as an argument.

The following example creates a new comment and links it to a post.

use prisma::{comment, post};
 
let comment: comment::Data = client
    .comment()
    .create(
        "content".to_string(),
        // If post wasn't required, then the equals() would need
        // to be wrapped in comment::post::connect(..).
        post::id::equals("id".to_string())
        vec![]
    )
    .exec()
    .await?;

Connecting records like this is equivalent to directly setting the values of the relation's foreign keys, eg. setting post_id from the above example with comment::post_id::set().

Create Unchecked

Available since v0.6.7

create_unchecked is similar to create but only allows setting scalar fields using UncheckedSetParam. unchecked is a Prisma term describing inputs that only accept a model's scalar fields.

use prisma::{comment, post};
 
let comment: comment::Data = client
    .comment()
    .create(
        "content".to_string(),
		// requires specifying field for postID,
		// rather than connecting a relation
        0,
        vec![]
    )
    .exec()
    .await?;

Create Many

create_many can be used to create many records of a single model type. It accepts a Vec of tuples with the same shape as create_unchecked, so only scalar fields can be set.

SQLite support for create_many is UNSTABLE, but can be enabled by adding the sqlite-create-many feature to prisma-client-rust and prisma-client-rust-cli in your Cargo.toml files.

To assist in constructing tuples of the right shape, each model module contains a create_unchecked function that accepts a model's scalar fields and returns the correct tuple.

The following example iterates an array of titles, turns it into tuples and creates multiple posts.

use prisma::post;
 
let titles = [
    "Title 1",
    "Title 2",
    "Title 3"
]
 
let posts: i64 = client
    .post()
    .create_many(
        titles
            .iter()
            .map(|title| post::create_unchecked(
                true,
                title.to_string(),
                vec![]
            ))
            .collect() // Necessary to create a Vec
    )
    .exec()
    .await?;

Skip Duplicates

The create_many builder has a skip_duplicates function which can be used to stop an error from being thrown if a unique constraint is violated, instead conflicting records will be ignored and the rest will be created.

client
    .post()
    .create_many(..)
    .skip_duplicates() // No error if unique violation is broken
    .exec()
    .await?

Order By Update Queries