Struct sea_orm::entity::prelude::Select

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

Implementations

impl<E> Select<E> where
    E: EntityTrait, 

pub fn from_raw_sql(self, stmt: Statement) -> SelectorRaw<SelectModel<E::Model>>

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

pub fn into_json(self) -> Selector<SelectModel<JsonValue>>

This is supported on crate feature with-json only.

pub fn into_values<T, C>(self) -> Selector<SelectGetableValue<T, C>> where
    T: TryGetableMany,
    C: IntoEnumIterator + Iden, 

use sea_orm::{entity::*, query::*, tests_cfg::cake, DeriveColumn, EnumIter};

#[derive(Copy, Clone, Debug, EnumIter, DeriveColumn)]
enum QueryAs {
    CakeName,
}

let res: Vec<String> = cake::Entity::find()
    .select_only()
    .column_as(cake::Column::Name, QueryAs::CakeName)
    .into_values::<_, QueryAs>()
    .all(&db)
    .await?;

assert_eq!(
    res,
    vec!["Chocolate Forest".to_owned(), "New York Cheese".to_owned()]
);

assert_eq!(
    db.into_transaction_log(),
    vec![Transaction::from_sql_and_values(
        DbBackend::Postgres,
        r#"SELECT "cake"."name" AS "cake_name" FROM "cake""#,
        vec![]
    )]
);

use sea_orm::{entity::*, query::*, tests_cfg::cake, DeriveColumn, EnumIter};

#[derive(Copy, Clone, Debug, EnumIter, DeriveColumn)]
enum QueryAs {
    CakeName,
    NumOfCakes,
}

let res: Vec<(String, i64)> = cake::Entity::find()
    .select_only()
    .column_as(cake::Column::Name, QueryAs::CakeName)
    .column_as(cake::Column::Id.count(), QueryAs::NumOfCakes)
    .group_by(cake::Column::Name)
    .into_values::<_, QueryAs>()
    .all(&db)
    .await?;

assert_eq!(res, vec![("Chocolate Forest".to_owned(), 2i64)]);

assert_eq!(
    db.into_transaction_log(),
    vec![Transaction::from_sql_and_values(
        DbBackend::Postgres,
        vec![
            r#"SELECT "cake"."name" AS "cake_name", COUNT("cake"."id") AS "num_of_cakes""#,
            r#"FROM "cake" GROUP BY "cake"."name""#,
        ]
        .join(" ")
        .as_str(),
        vec![]
    )]
);

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

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

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

pub fn paginate<'a, C>(
    self,
    db: &'a C,
    page_size: usize
) -> Paginator<'a, C, SelectModel<E::Model>> where
    C: ConnectionTrait<'a>, 

pub async fn count<'a, C>(self, db: &'a C) -> Result<usize, DbErr> where
    C: ConnectionTrait<'a>, 

impl<E> Select<E> where
    E: EntityTrait, 

pub fn select_also<F>(self, _: F) -> SelectTwo<E, F> where
    F: EntityTrait, 

pub fn select_with<F>(self, _: F) -> SelectTwoMany<E, F> where
    F: EntityTrait, 

impl<E> Select<E> where
    E: EntityTrait, 

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

Left Join with a Related Entity.

pub fn right_join<R>(self, _: R) -> Self where
    R: EntityTrait,
    E: Related<R>, 

Right Join with a Related Entity.

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

Inner Join with a Related Entity.

pub fn reverse_join<R>(self, _: R) -> Self where
    R: EntityTrait + Related<E>, 

Join with an Entity Related to me.

pub fn find_also_related<R>(self, r: R) -> SelectTwo<E, R> where
    R: EntityTrait,
    E: Related<R>, 

Left Join with a Related Entity and select both Entity.

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

Left Join with a Related Entity and select the related Entity as a Vec

pub fn find_also_linked<L, T>(self, l: L) -> SelectTwo<E, T> where
    L: Linked<FromEntity = E, ToEntity = T>,
    T: EntityTrait, 

Left Join with a Linked Entity and select both Entity.

Trait Implementations

impl<E: Clone> Clone for Select<E> where
    E: EntityTrait, 

fn clone(&self) -> Select<E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug> Debug for Select<E> where
    E: EntityTrait, 

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

Formats the value using the given formatter.

impl<E> QueryFilter for Select<E> where
    E: EntityTrait, 

type QueryStatement = SelectStatement

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

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, 

impl<E> QueryOrder for Select<E> where
    E: EntityTrait, 

type QueryStatement = SelectStatement

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

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> QuerySelect for Select<E> where
    E: EntityTrait, 

type QueryStatement = SelectStatement

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

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 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> QueryTrait for Select<E> where
    E: EntityTrait, 

type QueryStatement = SelectStatement

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