Struct SelectorRaw 

pub struct SelectorRaw<S>
where
    S: SelectorTrait,
{
    pub(crate) stmt: Statement,
    selector: S,
}

Performs a raw SELECT operation on a model

Fields

stmt: Statement

selector: S

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""#,
        [],
    ))
    .into_model::<SelectResult>()
    .all(&db)
    .await?;

assert_eq!(
    res,
    [
        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(),
    [Transaction::from_sql_and_values(
        DbBackend::Postgres,
        r#"SELECT "cake"."name", count("cake"."id") AS "num_of_cakes" FROM "cake""#,
        []
    ),]
);

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

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""#, []
    )
)
.into_json()
.all(&db)
.await?;

assert_eq!(
    res,
    [
        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(),
    [
    Transaction::from_sql_and_values(
            DbBackend::Postgres, r#"SELECT "cake"."id", "cake"."name" FROM "cake""#, []
    ),
]);

pub fn into_statement(self) -> Statement

Get the SQL statement

pub async fn one<'a, C>( self, db: &C, ) -> Result<Option<<S as SelectorTrait>::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"#,
        [1.into()],
    ))
    .one(&db)
    .await?;

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

pub async fn all<'a, C>( self, db: &C, ) -> Result<Vec<<S as SelectorTrait>::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""#,
        [],
    ))
    .all(&db)
    .await?;

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

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

where 'a: 'b, C: ConnectionTrait + StreamTrait + Send, S: 'b, <S as SelectorTrait>::Item: Send,

Stream the results of the Select operation

Trait Implementations

impl<S> Clone for SelectorRaw<S>

where S: Clone + SelectorTrait,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Debug for SelectorRaw<S>

where S: Debug + SelectorTrait,

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

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

Perform a count on the paginated results