Struct FindFirstOperation 

pub struct FindFirstOperation<E: QueryEngine, M: Model> {
    pub extra_projections: Vec<ScalarProjection>,
    /* private fields */
}

A query operation that finds the first record matching the filter.

Unlike FindUnique, this doesn’t require a unique constraint.

Example

let user = client
    .user()
    .find_first()
    .r#where(user::email::contains("@example.com"))
    .order_by(user::created_at::desc())
    .exec()
    .await?;

Fields

extra_projections: Vec<ScalarProjection>

Extra scalar-subquery columns appended to the SELECT clause. Used by relation-aggregate virtual fields (@count, @sum, …).

Implementations

impl<E: QueryEngine, M: Model + FromRow> FindFirstOperation<E, M>

pub fn new(engine: E) -> Self

Create a new FindFirst operation.

pub fn where(self, filter: impl Into<Filter>) -> Self

Add a filter condition.

pub fn order_by(self, order: impl Into<OrderBy>) -> Self

Set the order by clause.

pub fn select(self, select: impl Into<Select>) -> Self

Select specific fields.

pub fn include(self, spec: IncludeSpec) -> Self

Eager-load a relation alongside the first-match lookup.

pub fn with_where_input<W: WhereInput<Model = M>>(self, w: W) -> Self

Apply a typed WhereInput. AND-composes with any previously set filter — same semantics as calling .r#where(...) again.

pub fn with_include_input<I: IncludeInput<Model = M>>(self, i: I) -> Self

Apply a typed IncludeInput. Merges into any previously set includes (later wins on conflicting relation names).

pub fn with_select_input<S: SelectInput<Model = M>>(self, s: S) -> Self

Apply a typed SelectInput.

pub fn with_order_by_input<O: OrderByInput<Model = M>>(self, o: O) -> Self

Apply a typed OrderByInput (replaces current).

impl<E, M> FindFirstOperation<E, M>

where E: QueryEngine + SupportsScalarSubqueryInSelect, M: Model + FromRow,

pub fn with_scalar_projection(self, proj: ScalarProjection) -> Self

Append a scalar-subquery projection to the SELECT list.

Available only on engines that implement SupportsScalarSubqueryInSelect. SQL backends (Postgres, MySQL, SQLite, MSSQL, DuckDB, SQLx) all satisfy this bound; MongoDB, ScyllaDB, and Cassandra do not — calling this method on those engines is a compile-time error.

impl<E: QueryEngine, M: Model + FromRow> FindFirstOperation<E, M>

pub fn build_sql(&self, dialect: &dyn SqlDialect) -> (String, Vec<FilterValue>)

Build the SQL query.

pub async fn exec(self) -> QueryResult<Option<M>>

where M: Send + 'static + ModelRelationLoader<E>,

Execute the query and return an optional result.

pub async fn exec_required(self) -> QueryResult<M>

where M: Send + 'static + ModelRelationLoader<E>,

Execute the query and error if not found.