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: &CratestackContext) -> String

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

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

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

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: 'static, PK: 'static> From<FindMany<'a, M, PK>> for AggregateCount<'a, M, PK>

Reuses the exact filters a find_many builder assembled for a FindMany, discarding order_by/limit/offset/for_update — meaningless for a scalar COUNT(*). Both FindMany::run and AggregateCount::run push their WHERE clause through the same [push_scoped_conditions] with the same descriptor and [ReadPolicyKind::List], so transferring filters verbatim (rather than re-deriving them from the caller’s query a second time) is what guarantees the count can’t apply a different WHERE clause or policy scope than the page it describes — see cratestack#570, whose whole risk was exactly that kind of divergence.

fn from(find_many: FindMany<'a, M, PK>) -> Self

Converts to this type from the input type.