Struct Select

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

Defines a structure to perform select operations

Implementations

impl<E, M> Select<E>

where E: EntityTrait<Model = M>, M: FromQueryResult + Send + Sync,

pub fn cursor_by<C>(self, order_columns: C) -> Cursor<SelectModel<M>>

where C: IntoIdentity,

Convert into a cursor

impl<E> Select<E>

where E: EntityTrait,

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

Perform a Select operation on a Model using a Statement

pub fn into_model<M>(self) -> Selector<SelectModel<M>>

where M: FromQueryResult,

Return a Selector from Self that wraps a SelectModel

pub fn into_partial_model<M>(self) -> Selector<SelectModel<M>>

where M: PartialModelTrait,

Return a Selector from Self that wraps a SelectModel with a PartialModel

use sea_orm::{
    entity::*,
    query::*,
    tests_cfg::cake::{self, Entity as Cake},
    DbBackend, DerivePartialModel, FromQueryResult,
};
use sea_query::{Expr, Func, SimpleExpr};

#[derive(DerivePartialModel, FromQueryResult)]
#[sea_orm(entity = "Cake")]
struct PartialCake {
    name: String,
    #[sea_orm(
        from_expr = r#"SimpleExpr::FunctionCall(Func::upper(Expr::col((Cake, cake::Column::Name))))"#
    )]
    name_upper: String,
}

assert_eq!(
    cake::Entity::find()
        .into_partial_model::<PartialCake>()
        .into_statement(DbBackend::Sqlite)
        .to_string(),
    r#"SELECT "cake"."name" AS "name", UPPER("cake"."name") AS "name_upper" FROM "cake""#
);

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

Get a selectable Model as a JsonValue for SQL JSON operations

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,
    ["Chocolate Forest".to_owned(), "New York Cheese".to_owned()]
);

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

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, [("Chocolate Forest".to_owned(), 2i64)]);

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

pub fn into_tuple<T>(self) -> Selector<SelectGetableTuple<T>>

where T: TryGetableMany,

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

let res: Vec<String> = cake::Entity::find()
    .select_only()
    .column(cake::Column::Name)
    .into_tuple()
    .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" FROM "cake""#,
        vec![]
    )]
);

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

let res: Vec<(String, i64)> = cake::Entity::find()
    .select_only()
    .column(cake::Column::Name)
    .column(cake::Column::Id)
    .group_by(cake::Column::Name)
    .into_tuple()
    .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", "cake"."id""#,
            r#"FROM "cake" GROUP BY "cake"."name""#,
        ]
        .join(" ")
        .as_str(),
        vec![]
    )]
);

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

where C: ConnectionTrait,

Get one Model from the SELECT query

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

where C: ConnectionTrait,

Get all Models from the SELECT query

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

where 'a: 'b, C: ConnectionTrait + StreamTrait + Send,

Stream the results of a SELECT operation on a Model

pub async fn stream_partial_model<'a, 'b, C, M>( self, db: &'a C, ) -> Result<impl Stream<Item = Result<M, DbErr>> + Send + 'b, DbErr>

where 'a: 'b, C: ConnectionTrait + StreamTrait + Send, M: PartialModelTrait + Send + 'b,

Stream the result of the operation with PartialModel

impl<E> Select<E>

where E: EntityTrait,

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

where F: EntityTrait,

Selects extra Entity and returns it together with the Entity from Self

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

where F: EntityTrait,

Makes a SELECT operation in conjunction to another relation

impl<E> Select<E>

where E: EntityTrait,

pub fn left_join<R>(self, _: R) -> Select<E>

where R: EntityTrait, E: Related<R>,

Left Join with a Related Entity.

pub fn right_join<R>(self, _: R) -> Select<E>

where R: EntityTrait, E: Related<R>,

Right Join with a Related Entity.

pub fn inner_join<R>(self, _: R) -> Select<E>

where R: EntityTrait, E: Related<R>,

Inner Join with a Related Entity.

pub fn reverse_join<R>(self, _: R) -> Select<E>

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.

pub fn find_with_linked<L, T>(self, l: L) -> SelectTwoMany<E, T>

where L: Linked<FromEntity = E, ToEntity = T>, T: EntityTrait,

Left Join with a Linked Entity and select Entity as a Vec.

Trait Implementations

impl<E> Clone for Select<E>

where E: Clone + 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, M> CursorTrait for Select<E>

where E: EntityTrait<Model = M>, M: FromQueryResult + Send + Sync,

type Selector = SelectModel<M>

Select operation

impl<E> Debug for Select<E>

where E: Debug + EntityTrait,

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

Formats the value using the given formatter.

impl<E> EntityOrSelect<E> for Select<E>

where E: EntityTrait,

fn select(self) -> Select<E>

If self is Entity, use Entity::find()

impl<'db, C, M, E> PaginatorTrait<'db, C> for Select<E>

where C: ConnectionTrait, E: EntityTrait<Model = M>, M: FromQueryResult + Send + Sync + 'db,

type Selector = SelectModel<M>

Select operation

fn paginate( self, db: &'db C, page_size: u64, ) -> Paginator<'db, C, <Select<E> as PaginatorTrait<'db, C>>::Selector>

Paginate the result of a select operation.

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

where 'db: 'async_trait, Self: Sized + Send + 'async_trait,

Perform a count on the paginated results

impl<E> QueryFilter for Select<E>

where E: 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> QueryOrder for Select<E>

where E: 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)

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> QuerySelect for Select<E>

where E: 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 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 expr_as_<T, A>(self, expr: T, alias: A) -> Self

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

Same as expr_as. Here for legacy reasons.

fn tbl_col_as<T, C, A>(self, _: (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> QueryTrait for Select<E>

where E: 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: DatabaseBackend) -> 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(_)