Struct sea_orm::entity::prelude::Select

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

Defines a structure to perform select operations

Implementations

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

pub fn from_raw_sql(self, stmt: Statement) -> SelectorRaw<SelectModel<E::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

Examples found in repository

src/executor/paginator.rs (line 283)

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

src/executor/select.rs (line 261)

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

    /// Get all Models from the SELECT query
    pub async fn all<'a, C>(self, db: &C) -> Result<Vec<E::Model>, DbErr>
    where
        C: ConnectionTrait,
    {
        self.into_model().all(db).await
    }

    /// Stream the results of a SELECT operation on a Model
    pub async fn stream<'a: 'b, 'b, C>(
        self,
        db: &'a C,
    ) -> Result<impl Stream<Item = Result<E::Model, DbErr>> + 'b + Send, DbErr>
    where
        C: ConnectionTrait + StreamTrait + Send,
    {
        self.into_model().stream(db).await
    }

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

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

Get one Model from the SELECT query

Examples found in repository

src/executor/insert.rs (line 203)

async fn exec_insert_with_returning<A, C>(
    primary_key: Option<ValueTuple>,
    mut insert_statement: InsertStatement,
    db: &C,
) -> Result<<A::Entity as EntityTrait>::Model, DbErr>
where
    <A::Entity as EntityTrait>::Model: IntoActiveModel<A>,
    C: ConnectionTrait,
    A: ActiveModelTrait,
{
    let db_backend = db.get_database_backend();
    let found = match db.support_returning() {
        true => {
            let returning = Query::returning().exprs(
                <A::Entity as EntityTrait>::Column::iter()
                    .map(|c| cast_enum_as_text(Expr::col(c), &c)),
            );
            insert_statement.returning(returning);
            SelectorRaw::<SelectModel<<A::Entity as EntityTrait>::Model>>::from_statement(
                db_backend.build(&insert_statement),
            )
            .one(db)
            .await?
        }
        false => {
            let insert_res =
                exec_insert::<A, _>(primary_key, db_backend.build(&insert_statement), db).await?;
            <A::Entity as EntityTrait>::find_by_id(insert_res.last_insert_id)
                .one(db)
                .await?
        }
    };
    match found {
        Some(model) => Ok(model),
        None => Err(DbErr::RecordNotFound(
            "Failed to find inserted item".to_owned(),
        )),
    }
}

src/executor/update.rs (line 122)

async fn exec_update_and_return_updated<A, C>(
    mut query: UpdateStatement,
    model: A,
    db: &C,
) -> Result<<A::Entity as EntityTrait>::Model, DbErr>
where
    A: ActiveModelTrait,
    C: ConnectionTrait,
{
    match db.support_returning() {
        true => {
            let returning = Query::returning().exprs(
                <A::Entity as EntityTrait>::Column::iter()
                    .map(|c| cast_enum_as_text(Expr::col(c), &c)),
            );
            query.returning(returning);
            let db_backend = db.get_database_backend();
            let found: Option<<A::Entity as EntityTrait>::Model> =
                SelectorRaw::<SelectModel<<A::Entity as EntityTrait>::Model>>::from_statement(
                    db_backend.build(&query),
                )
                .one(db)
                .await?;
            // If we got `None` then we are updating a row that does not exist.
            match found {
                Some(model) => Ok(model),
                None => Err(DbErr::RecordNotFound(
                    "None of the database rows are affected".to_owned(),
                )),
            }
        }
        false => {
            // If we updating a row that does not exist then an error will be thrown here.
            Updater::new(query).check_record_exists().exec(db).await?;
            let primary_key_value = match model.get_primary_key_value() {
                Some(val) => FromValueTuple::from_value_tuple(val),
                None => return Err(DbErr::UpdateGetPrimaryKey),
            };
            let found = <A::Entity as EntityTrait>::find_by_id(primary_key_value)
                .one(db)
                .await?;
            // If we cannot select the updated row from db by the cached primary key
            match found {
                Some(model) => Ok(model),
                None => Err(DbErr::RecordNotFound(
                    "Failed to find updated item".to_owned(),
                )),
            }
        }
    }
}

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

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, DbErr>> + 'b + Send, DbErr>where
    C: ConnectionTrait + StreamTrait + Send,

Stream the results of a SELECT operation on a Model

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

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

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

Examples found in repository

src/query/join.rs (line 53)

    pub fn find_also_related<R>(self, r: R) -> SelectTwo<E, R>
    where
        R: EntityTrait,
        E: Related<R>,
    {
        self.left_join(r).select_also(r)
    }

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

Makes a SELECT operation in conjunction to another relation

Examples found in repository

src/query/join.rs (line 62)

    pub fn find_with_related<R>(self, r: R) -> SelectTwoMany<E, R>
    where
        R: EntityTrait,
        E: Related<R>,
    {
        self.left_join(r).select_with(r)
    }

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

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

Left Join with a Related Entity.

Examples found in repository

src/query/join.rs (line 53)

    pub fn find_also_related<R>(self, r: R) -> SelectTwo<E, R>
    where
        R: EntityTrait,
        E: Related<R>,
    {
        self.left_join(r).select_also(r)
    }

    /// Left Join with a Related Entity and select the related Entity as a `Vec`
    pub fn find_with_related<R>(self, r: R) -> SelectTwoMany<E, R>
    where
        R: EntityTrait,
        E: Related<R>,
    {
        self.left_join(r).select_with(r)
    }

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

Right Join with a Related Entity.

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

Inner Join with a Related Entity.

pub fn reverse_join<R>(self, _: R) -> Selfwhere
    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 for Select<E>where
    E: EntityTrait + Clone,

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 + Sized + Send + Sync,

type Selector = SelectModel<M>

Select operation

fn cursor_by<C>(self, order_columns: C) -> Cursor<Self::Selector>where
    C: IntoIdentity,

Convert current type into a cursor

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

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

Formats the value using the given formatter.

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

type Selector = SelectModel<M>

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<'async_trait>(
    self,
    db: &'db C
) -> Pin<Box<dyn Future<Output = Result<u64, DbErr>> + Send + 'async_trait>>where
    Self: Send + Sized + Send + 'async_trait,
    'db: '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) -> 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> 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) -> 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> 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) -> 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(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) -> 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> 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: DbBackend) -> Statement

Build the query as Statement