Struct sea_orm::SelectorRaw

pub struct SelectorRaw<S>where
    S: SelectorTrait,{ /* private fields */ }

Performs a raw SELECT operation on a model

Implementations

impl<S> SelectorRaw<S>where
    S: SelectorTrait,

pub fn from_statement<M>(stmt: Statement) -> SelectorRaw<SelectModel<M>>where
    M: FromQueryResult,

Select a custom Model from a raw SQL Statement.

Examples found in repository

src/entity/model.rs (line 115)

    fn find_by_statement(stmt: Statement) -> SelectorRaw<SelectModel<Self>> {
        SelectorRaw::<SelectModel<Self>>::from_statement(stmt)
    }

src/executor/insert.rs (lines 193-195)

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 (lines 101-103)

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 fn with_columns<T, C>(
    stmt: Statement
) -> SelectorRaw<SelectGetableValue<T, C>>where
    T: TryGetableMany,
    C: IntoEnumIterator + Iden,

Create SelectorRaw from Statement and columns. Executing this SelectorRaw will return a type T which implement TryGetableMany.

Examples found in repository

src/executor/query.rs (line 599)

    fn find_by_statement<C>(stmt: Statement) -> SelectorRaw<SelectGetableValue<Self, C>>
    where
        C: strum::IntoEnumIterator + sea_query::Iden,
    {
        SelectorRaw::<SelectGetableValue<Self, C>>::with_columns(stmt)
    }

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

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

#[derive(Debug, PartialEq, FromQueryResult)]
struct SelectResult {
    name: String,
    num_of_cakes: i32,
}

let res: Vec<SelectResult> = cake::Entity::find()
    .from_raw_sql(Statement::from_sql_and_values(
        DbBackend::Postgres,
        r#"SELECT "cake"."name", count("cake"."id") AS "num_of_cakes" FROM "cake""#,
        vec![],
    ))
    .into_model::<SelectResult>()
    .all(&db)
    .await?;

assert_eq!(
    res,
    vec![
        SelectResult {
            name: "Chocolate Forest".to_owned(),
            num_of_cakes: 1,
        },
        SelectResult {
            name: "New York Cheese".to_owned(),
            num_of_cakes: 1,
        },
    ]
);

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

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

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

let res: Vec<serde_json::Value> = cake::Entity::find().from_raw_sql(
    Statement::from_sql_and_values(
        DbBackend::Postgres, r#"SELECT "cake"."id", "cake"."name" FROM "cake""#, vec![]
    )
)
.into_json()
.all(&db)
.await?;

assert_eq!(
    res,
    vec![
        serde_json::json!({
            "name": "Chocolate Forest",
            "num_of_cakes": 1,
        }),
        serde_json::json!({
            "name": "New York Cheese",
            "num_of_cakes": 1,
        }),
    ]
);

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

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

Get an item from the Select query

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

let _: Option<cake::Model> = cake::Entity::find()
    .from_raw_sql(Statement::from_sql_and_values(
        DbBackend::Postgres,
        r#"SELECT "cake"."id", "cake"."name" FROM "cake" WHERE "id" = $1"#,
        vec![1.into()],
    ))
    .one(&db)
    .await?;

assert_eq!(
    db.into_transaction_log(),
    vec![Transaction::from_sql_and_values(
        DbBackend::Postgres,
        r#"SELECT "cake"."id", "cake"."name" FROM "cake" WHERE "id" = $1"#,
        vec![1.into()]
    ),]
);

Examples found in repository

src/executor/select.rs (line 439)

    pub async fn one<'a, C>(mut self, db: &C) -> Result<Option<S::Item>, DbErr>
    where
        C: ConnectionTrait,
    {
        self.query.limit(1);
        self.into_selector_raw(db).one(db).await
    }

src/executor/insert.rs (line 196)

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 104)

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<S::Item>, DbErr>where
    C: ConnectionTrait,

Get all items from the Select query

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

let _: Vec<cake::Model> = cake::Entity::find()
    .from_raw_sql(Statement::from_sql_and_values(
        DbBackend::Postgres,
        r#"SELECT "cake"."id", "cake"."name" FROM "cake""#,
        vec![],
    ))
    .all(&db)
    .await?;

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

Examples found in repository

src/executor/select.rs (line 447)

    pub async fn all<'a, C>(self, db: &C) -> Result<Vec<S::Item>, DbErr>
    where
        C: ConnectionTrait,
    {
        self.into_selector_raw(db).all(db).await
    }

pub async fn stream<'a: 'b, 'b, C>(
    self,
    db: &'a C
) -> Result<Pin<Box<dyn Stream<Item = Result<S::Item, DbErr>> + Send + 'b>>, DbErr>where
    C: ConnectionTrait + StreamTrait + Send,
    S: 'b,
    S::Item: Send,

Stream the results of the Select operation

Examples found in repository

src/executor/select.rs (line 460)

    pub async fn stream<'a: 'b, 'b, C>(
        self,
        db: &'a C,
    ) -> Result<Pin<Box<dyn Stream<Item = Result<S::Item, DbErr>> + 'b + Send>>, DbErr>
    where
        C: ConnectionTrait + StreamTrait + Send,
        S: 'b,
        S::Item: Send,
    {
        self.into_selector_raw(db).stream(db).await
    }

Trait Implementations

impl<S> Clone for SelectorRaw<S>where
    S: SelectorTrait + Clone,

fn clone(&self) -> SelectorRaw<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S> Debug for SelectorRaw<S>where
    S: SelectorTrait + Debug,

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

Formats the value using the given formatter.

impl<'db, C, S> PaginatorTrait<'db, C> for SelectorRaw<S>where
    C: ConnectionTrait,
    S: SelectorTrait + Send + Sync + 'db,

type Selector = S

Select operation

fn paginate(self, db: &'db C, page_size: u64) -> Paginator<'db, C, S>

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