Struct sea_orm::query::SelectTwo

pub struct SelectTwo<E, F> where
    E: EntityTrait,
    F: EntityTrait,  { /* fields omitted */ }

Defines a structure to perform a SELECT operation on two Models

Implementations

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

pub fn into_model<M, N>(self) -> Selector<SelectTwoModel<M, N>> where
    M: FromQueryResult,
    N: FromQueryResult, 

Perform a conversion into a SelectTwoModel

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

Convert the Models into JsonValue

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

Get one Model from the Select query

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

Get all Models from the Select query

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

Stream the results of a Select operation on a Model

Trait Implementations

impl<E: Clone, F: Clone> Clone for SelectTwo<E, F> where
    E: EntityTrait,
    F: EntityTrait, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug, F: Debug> Debug for SelectTwo<E, F> where
    E: EntityTrait,
    F: EntityTrait, 

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

Formats the value using the given formatter.

impl<'db, C, M, N, E, F> PaginatorTrait<'db, C> for SelectTwo<E, F> where
    C: ConnectionTrait<'db>,
    E: EntityTrait<Model = M>,
    F: EntityTrait<Model = N>,
    M: FromQueryResult + Sized + Send + Sync + 'db,
    N: FromQueryResult + Sized + Send + Sync + 'db, 

type Selector = SelectTwoModel<M, N>

Select operation

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

Paginate the result of a select operation.

fn count<'async_trait>(
    self,
    db: &'db C
) -> Pin<Box<dyn Future<Output = Result<usize, DbErr>> + Send + 'async_trait>> where
    Self: Send + Sized,
    'db: 'async_trait,
    Self: Send + 'async_trait, 

Perform a count on the paginated results

impl<E, F> QueryFilter for SelectTwo<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) -> Self where
    F: IntoCondition, 

Add an AND WHERE expression

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, 

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

impl<E, F> QueryOrder for SelectTwo<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) -> 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)

impl<E, F> QuerySelect for SelectTwo<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) -> Self where
    C: ColumnTrait, 

Add a select column

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

Add a select column with alias

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

Add an offset expression

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

Add a limit expression

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 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 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 SelectTwo<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