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.

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.

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()]
    ),]
);

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![]
    ),]
);

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

Trait Implementations

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

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> Debug for SelectorRaw<S>where
    S: SelectorTrait,

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,
    'db: 'async_trait,
    Self: Send + 'async_trait,

Perform a count on the paginated results