Struct FindMany 

pub struct FindMany<'a, M: 'static, PK: 'static> { /* private fields */ }

Implementations

impl<'a, M: 'static, PK: 'static> FindMany<'a, M, PK>

pub fn where_(self, filter: Filter) -> Self

pub fn where_expr(self, filter: FilterExpr) -> Self

pub fn where_any(self, filters: impl IntoIterator<Item = FilterExpr>) -> Self

pub fn where_optional<F>(self, filter: Option<F>) -> Self

where F: Into<FilterExpr>,

Conditionally append a filter. None is a no-op so callers can pipe FieldRef::match_optional(...) results straight in without an if let ladder at every optional-param site.

pub fn order_by(self, clause: OrderClause) -> Self

pub fn limit(self, limit: i64) -> Self

pub fn offset(self, offset: i64) -> Self

pub fn for_update(self) -> Self

Emit SELECT ... FOR UPDATE so the engine takes an exclusive row-level lock on every matched row for the surrounding transaction. Only meaningful when paired with Self::run_in_tx.

pub fn preview_sql(&self) -> String

pub fn preview_scoped_sql(&self, ctx: &CoolContext) -> String

pub async fn run(self, ctx: &CoolContext) -> Result<Vec<M>, CoolError>

where for<'r> M: Send + Unpin + FromRow<'r, PgRow>,

pub async fn run_in_tx<'tx>( self, tx: &mut Transaction<'tx, Postgres>, ctx: &CoolContext, ) -> Result<Vec<M>, CoolError>

where for<'r> M: Send + Unpin + FromRow<'r, PgRow>,

Run inside a caller-supplied transaction. Required when pairing with Self::for_update.

pub fn include<Rel, RelPK>( self, relation: RelationInclude<M, Rel, RelPK>, ) -> FindManyWith<'a, M, PK, Rel, RelPK>

where Rel: 'static, RelPK: 'static,

Side-load a to-one relation alongside the matched rows. Two queries, not a SQL JOIN, so the related-side read policy + soft-delete inherit from find_many for free.

impl<'a, M: 'static, PK: 'static> FindMany<'a, M, PK>

pub fn select<I, C>(self, columns: I) -> ProjectedFindMany<'a, M, PK>

where I: IntoIterator<Item = C>, C: IntoColumnName,

Restrict the SELECT to the named columns. See super::find_unique::FindUnique::select for the caller-side contract.

Trait Implementations

impl<'a, M: Clone + 'static, PK: Clone + 'static> Clone for FindMany<'a, M, PK>

fn clone(&self) -> FindMany<'a, M, PK>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, M: Debug + 'static, PK: Debug + 'static> Debug for FindMany<'a, M, PK>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.