Struct Select 

pub struct Select<E: EntityTrait> { /* private fields */ }

A SELECT on one entity, decoded into its model.

Implementations

impl<E: EntityTrait> Select<E>

pub fn filter(self, cond: impl IntoCondition) -> Self

Adds a WHERE condition, ANDed with the previous ones.

pub fn filter_option(self, cond: Option<impl IntoCondition>) -> Self

Adds a WHERE condition only when cond is Some.

pub fn related_to<M: ModelTrait>(self, rel: &RelationDef, model: &M) -> Self

Restricts the query to the rows of E related to model through rel, whose from_tbl is the model’s table and to_tbl is E’s.

This is the explicit form of ModelTrait::find_related for a relation that is not the one Related names: a second relation to the same entity, or the children side of a self-referencing relation.

pub fn order_by(self, column: E::Column, order: Order) -> Self

Adds ORDER BY column in the given direction.

pub fn order_by_asc(self, column: E::Column) -> Self

Adds ORDER BY column ASC.

pub fn order_by_desc(self, column: E::Column) -> Self

Adds ORDER BY column DESC.

pub fn order_by_expr(self, expr: Expr, order: Order) -> Self

Adds ORDER BY expr in the given direction.

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

Sets LIMIT.

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

Sets OFFSET.

pub fn distinct(self) -> Self

Makes the query SELECT DISTINCT.

pub fn group_by(self, column: E::Column) -> Self

Adds GROUP BY column.

pub fn group_by_expr(self, expr: Expr) -> Self

Adds GROUP BY expr.

pub fn having(self, cond: impl IntoCondition) -> Self

Adds a HAVING condition, ANDed with the previous ones.

pub fn select_only(self) -> Self

Clears the select list, to be rebuilt with column, column_as or expr_as and decoded with into_model or into_tuple.

pub fn column(self, column: E::Column) -> Self

Adds a column of E to the select list.

pub fn column_as(self, column: E::Column, alias: impl IntoIden) -> Self

Adds a column of E to the select list under alias.

pub fn expr(self, expr: Expr) -> Self

Adds an expression to the select list.

pub fn expr_as(self, expr: Expr, alias: impl IntoIden) -> Self

Adds an aliased expression to the select list.

pub fn join(self, kind: JoinType, rel: &RelationDef) -> Self

Joins the target of rel, a relation declared on E.

The joined table is aliased table_n when it is already part of the query, as for a self-referencing relation; use join_as to choose the alias.

pub fn join_as( self, kind: JoinType, rel: &RelationDef, alias: &'static str, ) -> Self

Joins the target of rel under alias, so that filters can qualify its columns with Expr::col((alias, "column")).

pub fn join_rev(self, kind: JoinType, rel: &RelationDef) -> Self

Joins the entity declaring rel, following the relation in reverse.

pub fn inner_join<R: EntityTrait>(self, _: R) -> Self

where E: Related<R>,

Adds INNER JOIN to R through the relation E declares to it, joining the junction table first for a many-to-many relation.

pub fn left_join<R: EntityTrait>(self, _: R) -> Self

where E: Related<R>,

Adds LEFT JOIN to R through the relation E declares to it, joining the junction table first for a many-to-many relation.

pub fn find_also_related<R: EntityTrait>(self, _: R) -> SelectTwo<E, R>

where E: Related<R>,

Also selects the related R row through a LEFT JOIN.

The select list is rebuilt with every column of E aliased A_<col> and every column of R aliased B_<col>, so that both models can be decoded from one row even when they share column names. For a many-to-many relation a row is produced per junction entry.

pub fn find_with_related<R: EntityTrait>(self, r: R) -> SelectTwoMany<E, R>

where E: Related<R>,

Selects every E row together with all of its related R rows.

The statement is the one of find_also_related; the rows are folded so that each E model appears once, followed by the related models in row order.

pub fn find_also_linked<L>(self, link: &L) -> SelectTwo<E, L::ToEntity>

where L: Linked<FromEntity = E>,

Also selects the row at the end of the chain link, through LEFT JOINs.

Every table on the path is joined; only the first and the last are selected, as A_<col> and B_<col>.

pub fn find_with_linked<L>(self, link: &L) -> SelectTwoMany<E, L::ToEntity>

where L: Linked<FromEntity = E>,

Selects every E row together with all the rows at the end of link.

pub fn into_model<M: FromQueryResult>(self) -> Selector<M>

Decodes rows into M instead of the entity model.

pub fn into_partial_model<P: PartialModelTrait>(self) -> Selector<P>

Replaces the select list with the columns P reads and decodes rows into it.

pub fn into_tuple<T: FromQueryResult>(self) -> Selector<T>

Decodes rows into a tuple, by position in the select list.

Meant to follow select_only with as many items as the tuple has fields.

pub fn into_json(self) -> Selector<Value>

Available on crate feature with-json only.

Decodes rows into JSON objects keyed by column name.

pub fn from_raw_sql(self, statement: Statement) -> RawSelector<E::Model>

Runs statement as given and decodes its rows into the entity model.

The builder’s own clauses are discarded; this is the escape hatch for a SELECT the API cannot express.

pub fn as_query(&self) -> &Select

The underlying SQL builder.

pub fn query_mut(&mut self) -> &mut Select

Mutable access to the underlying SQL builder, for clauses this API does not expose.

pub fn into_query(self) -> Select

Takes the underlying SQL builder out of the select.

pub fn build(&self) -> Statement

Renders the statement.

pub async fn one<C: ConnectionTrait>(self, db: &C) -> Result<Option<E::Model>>

Fetches the first row, adding LIMIT 1.

Errors

Returns DbErr::Driver when the query fails or the row cannot be decoded.

pub async fn all<C: ConnectionTrait>(self, db: &C) -> Result<Vec<E::Model>>

Fetches every row.

Errors

Returns DbErr::Driver when the query fails or a row cannot be decoded.

pub async fn stream<C: StreamTrait>( self, db: &C, ) -> Result<ModelStream<'_, E::Model>>

Streams rows as they are read.

Errors

Returns DbErr::Driver when the query cannot be started; decoding failures surface as items of the stream.

pub async fn count<C: ConnectionTrait>(self, db: &C) -> Result<u64>

Counts the rows this query would return.

Errors

Returns DbErr::RecordNotFound when the count query returns no row; DbErr::Driver when the query fails.

pub async fn exists<C: ConnectionTrait>(self, db: &C) -> Result<bool>

Whether this query would return at least one row, through SELECT EXISTS (query).

Errors

Returns DbErr::RecordNotFound when the probe returns no row; DbErr::Driver when the query fails.

pub fn paginate<C: ConnectionTrait>( self, db: &C, page_size: u64, ) -> Paginator<'_, C, E::Model>

Paginates with page_size rows per page.

pub fn cursor_by<const N: usize>( self, columns: [E::Column; N], ) -> Cursor<E, E::Model>

Paginates by key over columns, most significant first; see Cursor.

Any ordering already on the query is replaced by the key order.

Trait Implementations

impl<E: Clone + EntityTrait> Clone for Select<E>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug + EntityTrait> Debug for Select<E>

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

Formats the value using the given formatter.