Struct SelectThree 

pub struct SelectThree<E, F, G, TOP>
where
    E: EntityTrait,
    F: EntityTrait,
    G: EntityTrait,
    TOP: Topology,
{ /* private fields */ }

Perform a SELECT operation on three Models

Implementations

impl<E, F, G, M, N, O, TOP> SelectThree<E, F, G, TOP>

where E: EntityTrait<Model = M>, F: EntityTrait<Model = N>, G: EntityTrait<Model = O>, M: FromQueryResult + Sized, N: FromQueryResult + Sized, O: FromQueryResult + Sized, TOP: Topology,

pub fn cursor_by<C>(self, order_columns: C) -> Cursor<SelectThreeModel<M, N, O>>

where C: IdentityOf<E>,

Convert into a cursor using column of first entity

impl<E, F, G, TOP> SelectThree<E, F, G, TOP>

where E: EntityTrait, F: EntityTrait, G: EntityTrait, TOP: Topology,

pub fn find_also<T, H>(self, _: T, _: H) -> SelectFour<E, F, G, H, TopologyStar>

where H: EntityTrait, T: EntityTrait + Related<H>,

Left Join with a Related Entity and select all Entities.

impl<E, F, G, TOP> SelectThree<E, F, G, TOP>

where E: EntityTrait, F: EntityTrait, G: EntityTrait, TOP: Topology,

pub fn into_model<M, N, O>(self) -> Selector<SelectThreeModel<M, N, O>>

where M: FromQueryResult, N: FromQueryResult, O: FromQueryResult,

Perform a conversion into a SelectThreeModel

pub fn into_partial_model<M, N, O>(self) -> Selector<SelectThreeModel<M, N, O>>

where M: PartialModelTrait, N: PartialModelTrait, O: PartialModelTrait,

Perform a conversion into a SelectThreeModel with PartialModel

pub fn into_json( self, ) -> Selector<SelectThreeModel<JsonValue, JsonValue, JsonValue>>

Available on crate feature with-json only.

Convert the Models into JsonValue

pub fn one<C>( self, db: &C, ) -> Result<Option<(E::Model, Option<F::Model>, Option<G::Model>)>, DbErr>

where C: ConnectionTrait,

Get one Model from the Select query

pub fn all<C>( self, db: &C, ) -> Result<Vec<(E::Model, Option<F::Model>, Option<G::Model>)>, DbErr>

where C: ConnectionTrait,

Get all Models from the Select query

pub fn stream<'a: 'b, 'b, C>( self, db: &'a C, ) -> Result<impl Iterator<Item = Result<(E::Model, Option<F::Model>, Option<G::Model>), DbErr>> + 'b, DbErr>

where C: ConnectionTrait + StreamTrait,

Stream the results of a Select operation on a Model

pub fn stream_partial_model<'a: 'b, 'b, C, M, N, O>( self, db: &'a C, ) -> Result<impl Iterator<Item = Result<(M, Option<N>, Option<O>), DbErr>> + 'b, DbErr>

where C: ConnectionTrait + StreamTrait, M: PartialModelTrait + 'b, N: PartialModelTrait + 'b, O: PartialModelTrait + 'b,

Stream the result of the operation with PartialModel

pub fn consolidate(self) -> SelectThreeMany<E, F, G, TOP>

Consolidate query result by first / second model depending on join topology

// fruit -> cake -> filling
let items: Vec<(fruit::Model, Vec<(cake::Model, Vec<filling::Model>)>)> = fruit::Entity::find()
    .find_also_related(cake::Entity)
    .and_also_related(filling::Entity)
    .consolidate()
    .all(db)
    ?;

// cake -> fruit
//      -> filling
let items: Vec<(cake::Model, Vec<fruit::Model>, Vec<filling::Model>)> = cake::Entity::find()
    .find_also_related(fruit::Entity)
    .find_also_related(filling::Entity)
    .consolidate()
    .all(db)
    ?;

Trait Implementations

impl<E, F, G, TOP> Clone for SelectThree<E, F, G, TOP>

where E: EntityTrait + Clone, F: EntityTrait + Clone, G: EntityTrait + Clone, TOP: Topology + Clone,

fn clone(&self) -> SelectThree<E, F, G, TOP>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E, F, G, M, N, O, TOP> CursorTrait for SelectThree<E, F, G, TOP>

where E: EntityTrait<Model = M>, F: EntityTrait<Model = N>, G: EntityTrait<Model = O>, M: FromQueryResult + Sized, N: FromQueryResult + Sized, O: FromQueryResult + Sized, TOP: Topology,

type Selector = SelectThreeModel<M, N, O>

Select operation

impl<E, F, G, TOP> Debug for SelectThree<E, F, G, TOP>

where E: EntityTrait + Debug, F: EntityTrait + Debug, G: EntityTrait + Debug, TOP: Topology + Debug,

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

Formats the value using the given formatter.

impl<'db, C, M, N, O, E, F, G, TOP> PaginatorTrait<'db, C> for SelectThree<E, F, G, TOP>

where C: ConnectionTrait, E: EntityTrait<Model = M>, F: EntityTrait<Model = N>, G: EntityTrait<Model = O>, M: FromQueryResult + Sized + 'db, N: FromQueryResult + Sized + 'db, O: FromQueryResult + Sized + 'db, TOP: Topology,

type Selector = SelectThreeModel<M, N, O>

Select operation

fn paginate( self, db: &'db C, page_size: u64, ) -> Paginator<'db, C, Self::Selector>

Paginate the result of a select operation.

fn count(self, db: &'db C) -> Result<u64, DbErr>

where Self: Sized,

Perform a count on the paginated results

fn exists(self, db: &'db C) -> Result<bool, DbErr>

where Self: Sized,

Check if any records exist

impl<E, F, G, TOP> QueryFilter for SelectThree<E, F, G, TOP>

where E: EntityTrait, F: EntityTrait, G: EntityTrait, TOP: Topology,

type QueryStatement = SelectStatement

fn query(&mut self) -> &mut SelectStatement

Add the query to perform a FILTER on

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

where F: IntoCondition,

Add an AND WHERE expression

fn filter_mut<F>(&mut self, filter: F)

where F: IntoCondition,

Like Self::filter, but without consuming self

fn belongs_to<M>(self, model: &M) -> Self

where M: ModelTrait,

Apply a where condition using the model’s primary key

fn belongs_to_tbl_alias<M>(self, model: &M, tbl_alias: &str) -> Self

where M: ModelTrait,

Like belongs_to, but via a table alias

impl<E, F, G, TOP> QueryOrder for SelectThree<E, F, G, TOP>

where E: EntityTrait, F: EntityTrait, G: EntityTrait, TOP: Topology,

type QueryStatement = SelectStatement

fn query(&mut self) -> &mut SelectStatement

Add the query to perform an ORDER BY operation

fn order_by<C>(self, col: C, ord: Order) -> Self

where C: IntoSimpleExpr,

Add an order_by expression

fn order_by_asc<C>(self, col: C) -> Self

where C: IntoSimpleExpr,

Add an order_by expression (ascending)

fn order_by_desc<C>(self, col: C) -> Self

where C: IntoSimpleExpr,

Add an order_by expression (descending)

fn order_by_with_nulls<C>(self, col: C, ord: Order, nulls: NullOrdering) -> Self

where C: IntoSimpleExpr,

Add an order_by expression with nulls ordering option

impl<E, F, G, TOP> QuerySelect for SelectThree<E, F, G, TOP>

where E: EntityTrait, F: EntityTrait, G: EntityTrait, TOP: Topology,

type QueryStatement = SelectStatement

fn query(&mut self) -> &mut SelectStatement

Add the select SQL statement

fn select_only(self) -> Self

Clear the selection list

fn column<C>(self, col: C) -> Self

where C: ColumnTrait,

Add a select column

fn column_as<C, I>(self, col: C, alias: I) -> Self

where C: ColumnAsExpr, I: IntoIdentity,

Add a select column with alias

fn columns<C, I>(self, cols: I) -> Self

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

Select columns

fn offset<T>(self, offset: T) -> Self

where T: Into<Option<u64>>,

Add an offset expression. Passing in None would remove the offset.

fn limit<T>(self, limit: T) -> Self

where T: Into<Option<u64>>,

Add a limit expression. Passing in None would remove the limit.

fn group_by<C>(self, col: C) -> Self

where C: IntoSimpleExpr,

Add a group by column

fn having<F>(self, filter: F) -> Self

where F: IntoCondition,

Add an AND HAVING expression

fn distinct(self) -> Self

Add a DISTINCT expression

fn distinct_on<T, I>(self, cols: I) -> Self

where T: IntoColumnRef, I: IntoIterator<Item = T>,

Add a DISTINCT ON expression NOTE: this function is only supported by sqlx-postgres

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

Join via RelationDef.

fn join_rev(self, join: JoinType, rel: RelationDef) -> Self

Join via RelationDef but in reverse direction. Assume when there exist a relation A to B. You can reverse join B from A.

fn join_as<I>(self, join: JoinType, rel: RelationDef, alias: I) -> Self

where I: IntoIden,

Join via RelationDef with table alias.

fn join_as_rev<I>(self, join: JoinType, rel: RelationDef, alias: I) -> Self

where I: IntoIden,

Join via RelationDef with table alias but in reverse direction. Assume when there exist a relation A to B. You can reverse join B from A.

fn lock(self, lock_type: LockType) -> Self

Select lock

fn lock_shared(self) -> Self

Select lock shared

fn lock_exclusive(self) -> Self

Select lock exclusive

fn lock_with_behavior(self, type: LockType, behavior: LockBehavior) -> Self

Row locking with behavior (if supported).

fn expr<T>(self, expr: T) -> Self

where T: Into<SelectExpr>,

Add an expression to the select expression list.

fn exprs<T, I>(self, exprs: I) -> Self

where T: Into<SelectExpr>, I: IntoIterator<Item = T>,

Add select expressions from vector of SelectExpr.

fn expr_as<T, A>(self, expr: T, alias: A) -> Self

where T: Into<SimpleExpr>, A: IntoIdentity,

Select column.

fn tbl_col_as<T, C, A>(self, (tbl, col): (T, C), alias: A) -> Self

where T: IntoIden + 'static, C: IntoIden + 'static, A: IntoIdentity,

Shorthand of expr_as(Expr::col((T, C)), A).

impl<E, F, G, TOP> QueryTrait for SelectThree<E, F, G, TOP>

where E: EntityTrait, F: EntityTrait, G: EntityTrait, TOP: Topology,

type QueryStatement = SelectStatement

Constrain the QueryStatement to StatementBuilder trait

fn query(&mut self) -> &mut SelectStatement

Get a mutable ref to the query builder

fn as_query(&self) -> &SelectStatement

Get an immutable ref to the query builder

fn into_query(self) -> SelectStatement

Take ownership of the query builder

fn build(&self, db_backend: DbBackend) -> Statement

Build the query as Statement

fn apply_if<T, F>(self, val: Option<T>, if_some: F) -> Self

where Self: Sized, F: FnOnce(Self, T) -> Self,

Apply an operation on the QueryTrait::QueryStatement if the given Option<T> is Some(_)