Struct ModelSelect 

pub struct ModelSelect<M: View> { /* private fields */ }

A model SELECT: the dialect statement plus the extension payloads the query carries — hooks, preload mapper mods, then-loaders.

Still a Query: build() hands back the same (String, Vec<Value>) escape hatch as everything else, and the raw Execute verbs keep working. The model verbs — all, one, optional — are the path that also runs the extensions, reading them back through QueryExtensions, which this type implements with the pinned payload types.

Layer 1 interop: the wrapper implements every Has* clause trait its statement implements (see delegate.rs), so shared dialect mods (select::limit(20), select::where_("raw sql"), joins, CTEs, …) apply to it directly, in the same tuple as typed filters. Statement-specific mods go through apply.

Implementations

impl<M: View> ModelSelect<M>

pub fn apply(&mut self, mods: impl Mod<M::Select>)

Apply mods written against the concrete dialect statement — the escape hatch for the statement-specific ones (psql’s select::distinct()) that are not generic over a Has* trait and so cannot land on the wrapper directly.

pub fn as_select(&self) -> &M::Select

The dialect statement, for inspection.

pub fn add_hook(&mut self, hook: ExecHook)

Attach a pre-query hook. Runs on the caller’s executor, before the statement, in attachment order.

pub fn add_mapper_mod(&mut self, mapper_mod: MapperMod<M::Row>)

Attach a mapper mod — generated preload mods call this.

pub fn add_loader(&mut self, loader: Loader<M::Row>)

Attach a then-loader — generated then-load mods call this.

pub async fn all(&self, db: &dyn Executor) -> Result<Vec<M::Row>, ExecError>

Every row, mapped, loaded, hooked.

The order is the contract: hooks → the statement (through the same traced verb funnel as everything else) → base FromRow plus mapper mods, per row → then-loaders → View::after_select. All of it on db, so inside db’s transaction when db is one.

pub async fn one(&self, db: &dyn Executor) -> Result<M::Row, ExecError>

Exactly one row — zero is ExecError::RowNotFound, two is ExecError::TooManyRows, matching the execution layer’s “one means one”.

pub async fn optional( &self, db: &dyn Executor, ) -> Result<Option<M::Row>, ExecError>

At most one row; a second is still ExecError::TooManyRows.

Trait Implementations

impl<M: View> Debug for ModelSelect<M>

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

Formats the value using the given formatter.

impl<M: View> Expression for ModelSelect<M>

fn write_sql(&self, w: &mut SqlWriter<'_>)

Append this fragment to w.

impl<M: View> HasCombines for ModelSelect<M>

where M::Select: HasCombines,

fn combines_mut(&mut self) -> &mut Combines

The set operations to modify.

impl<M: View> HasFetch for ModelSelect<M>

where M::Select: HasFetch,

fn fetch_mut(&mut self) -> &mut Fetch

The FETCH clause to modify.

impl<M: View> HasGroupBy for ModelSelect<M>

where M::Select: HasGroupBy,

fn group_by_mut(&mut self) -> &mut GroupBy

The GROUP BY clause to modify.

impl<M: View> HasHaving for ModelSelect<M>

where M::Select: HasHaving,

fn having_mut(&mut self) -> &mut Having

The HAVING clause to modify.

impl<M: View> HasJoins for ModelSelect<M>

where M::Select: HasJoins,

fn joins_mut(&mut self) -> &mut Vec<Join>

The join list to modify.

impl<M: View> HasLimit for ModelSelect<M>

where M::Select: HasLimit,

fn limit_mut(&mut self) -> &mut Limit

The LIMIT clause to modify.

impl<M: View> HasLocks for ModelSelect<M>

where M::Select: HasLocks,

fn locks_mut(&mut self) -> &mut Locks

The locking clauses to modify.

impl<M: View> HasOffset for ModelSelect<M>

where M::Select: HasOffset,

fn offset_mut(&mut self) -> &mut Offset

The OFFSET clause to modify.

impl<M: View> HasOrderBy for ModelSelect<M>

where M::Select: HasOrderBy,

fn order_by_mut(&mut self) -> &mut OrderBy

The ORDER BY clause to modify.

impl<M: View> HasSelectList for ModelSelect<M>

where M::Select: HasSelectList,

fn select_list_mut(&mut self) -> &mut SelectList

The projection to modify.

impl<M: View> HasTableRef for ModelSelect<M>

where M::Select: HasTableRef,

fn table_ref_mut(&mut self) -> &mut TableRef

The table reference to modify.

impl<M: View> HasWhere for ModelSelect<M>

where M::Select: HasWhere,

fn where_mut(&mut self) -> &mut Where

The WHERE clause to modify.

impl<M: View> HasWindows for ModelSelect<M>

where M::Select: HasWindows,

fn windows_mut(&mut self) -> &mut Windows

The WINDOW clause to modify.

impl<M: View> HasWith for ModelSelect<M>

where M::Select: HasWith,

fn with_mut(&mut self) -> &mut With

The WITH clause to modify.

impl<P, C, K> Mod<ModelSelect<P>> for ThenLoad<P, C, K>

where P: View, C: View, K: Ord + Clone + Send + Sync + 'static,

fn apply(self, q: &mut ModelSelect<P>)

Apply this modification to q.

impl<M: View> Query for ModelSelect<M>

fn query_type(&self) -> QueryType

Which statement this renders.

fn dialect(&self) -> &dyn Dialect

The dialect this query renders itself in.

fn build(&self) -> Result<(String, Vec<Value>), Error>

Render to SQL and arguments, numbering placeholders from 1.

fn build_from(&self, start: usize) -> Result<(String, Vec<Value>), Error>

build with a different first placeholder position, for splicing into a statement that already has arguments — bob’s BuildN.

impl<M: View> QueryExtensions<Arc<dyn for<'a> Fn(&'a dyn Executor) -> Pin<Box<dyn Future<Output = Result<(), ExecError>> + Send + 'a>> + Sync + Send>, Arc<dyn for<'a> Fn(&'a dyn Executor, &'a mut Vec<<M as View>::Row>) -> Pin<Box<dyn Future<Output = Result<(), ExecError>> + Send + 'a>> + Sync + Send>, Arc<dyn Fn(&mut Row, &mut <M as View>::Row) -> Result<(), ExecError> + Sync + Send>> for ModelSelect<M>

The extension points, answered with the pinned payload types — the completion of the QueryExtensions wiring core left with type parameters.

fn hooks(&self) -> &[ExecHook]

Hooks to run before this query executes.

fn loaders(&self) -> &[Loader<M::Row>]

Loaders to run after this query executes, for eagerly loaded relations.

fn mapper_mods(&self) -> &[MapperMod<M::Row>]

Adjustments to the row mapper, for relations loaded in the same query.