Struct sea_orm::query::SelectTwoMany

pub struct SelectTwoMany<E, F>where
    E: EntityTrait,
    F: EntityTrait,{ /* private fields */ }

Defines a structure to perform a SELECT operation on many Models

Implementations

impl<E, F> SelectTwoMany<E, F>where
    E: EntityTrait,
    F: EntityTrait,

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

Convert the results to JSON

pub async fn stream<'a: 'b, 'b, C>(
    self,
    db: &'a C
) -> Result<impl Stream<Item = Result<(E::Model, Option<F::Model>), DbErr>> + 'b + Send, DbErr>where
    C: ConnectionTrait + StreamTrait + Send,

Stream the result of the operation

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

Get all Models from the select operation

SelectTwoMany::one() method has been dropped (#486)

You can get (Entity, Vec<RelatedEntity>) by first querying a single model from Entity, then use ModelTrait::find_related on the model.

See https://www.sea-ql.org/SeaORM/docs/basic-crud/select#lazy-loading for details.

Trait Implementations

impl<E, F> Clone for SelectTwoMany<E, F>where
    E: EntityTrait + Clone,
    F: EntityTrait + Clone,

fn clone(&self) -> SelectTwoMany<E, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E, F> Debug for SelectTwoMany<E, F>where
    E: EntityTrait + Debug,
    F: EntityTrait + Debug,

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

Formats the value using the given formatter.

impl<E, F> QueryFilter for SelectTwoMany<E, F>where
    E: EntityTrait,
    F: EntityTrait,

type QueryStatement = SelectStatement

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

Add the query to perform a FILTER on

fn filter<F>(self, filter: F) -> Selfwhere
    F: IntoCondition,

Add an AND WHERE expression

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

Apply a where condition using the model’s primary key

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

Perform a check to determine table belongs to a Model through it’s name alias

impl<E, F> QueryOrder for SelectTwoMany<E, F>where
    E: EntityTrait,
    F: EntityTrait,

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) -> Selfwhere
    C: IntoSimpleExpr,

Add an order_by expression

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

Add an order_by expression (ascending)

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

Add an order_by expression (descending)

impl<E, F> QuerySelect for SelectTwoMany<E, F>where
    E: EntityTrait,
    F: EntityTrait,

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) -> Selfwhere
    C: ColumnTrait,

Add a select column

fn column_as<C, I>(self, col: C, alias: I) -> Selfwhere
    C: IntoSimpleExpr,
    I: IntoIdentity,

Add a select column with alias

fn columns<C, I>(self, cols: I) -> Selfwhere
    C: ColumnTrait,
    I: IntoIterator<Item = C>,

Select columns

fn offset<T>(self, offset: T) -> Selfwhere
    T: Into<Option<u64>>,

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

fn limit<T>(self, limit: T) -> Selfwhere
    T: Into<Option<u64>>,

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

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

Add a group by column

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

Add an AND HAVING expression

fn distinct(self) -> Self

Add a DISTINCT expression

fn distinct_on<T, I>(self, cols: I) -> Selfwhere
    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) -> Selfwhere
    I: IntoIden,

Join via RelationDef with table alias.

fn join_as_rev<I>(self, join: JoinType, rel: RelationDef, alias: I) -> Selfwhere
    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

impl<E, F> QueryTrait for SelectTwoMany<E, F>where
    E: EntityTrait,
    F: EntityTrait,

type QueryStatement = SelectStatement

Constrain the QueryStatement to QueryStatementBuilder 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) -> Selfwhere
    Self: Sized,
    F: FnOnce(Self, T) -> Self,

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