pub struct Select<E>where
E: EntityTrait,{ /* private fields */ }
Expand description
Defines a structure to perform select operations
Implementations§
source§impl<E> Select<E>where
E: EntityTrait,
impl<E> Select<E>where E: EntityTrait,
sourcepub fn from_raw_sql(self, stmt: Statement) -> SelectorRaw<SelectModel<E::Model>>
pub fn from_raw_sql(self, stmt: Statement) -> SelectorRaw<SelectModel<E::Model>>
Perform a Select operation on a Model using a Statement
sourcepub fn into_model<M>(self) -> Selector<SelectModel<M>>where
M: FromQueryResult,
pub fn into_model<M>(self) -> Selector<SelectModel<M>>where M: FromQueryResult,
Return a Selector from Self
that wraps a SelectModel
sourcepub fn into_partial_model<M>(self) -> Selector<SelectModel<M>>where
M: PartialModelTrait,
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", UPPER("cake"."name") AS "name_upper" FROM "cake""#
);
sourcepub fn into_json(self) -> Selector<SelectModel<JsonValue>>
pub fn into_json(self) -> Selector<SelectModel<JsonValue>>
Get a selectable Model as a JsonValue for SQL JSON operations
sourcepub fn into_values<T, C>(self) -> Selector<SelectGetableValue<T, C>>where
T: TryGetableMany,
C: IntoEnumIterator + Iden,
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(),
[]
)]
);
sourcepub fn into_tuple<T>(self) -> Selector<SelectGetableTuple<T>>where
T: TryGetableMany,
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![]
)]
);
sourcepub async fn one<'a, C>(self, db: &C) -> Result<Option<E::Model>, DbErr>where
C: ConnectionTrait,
pub async fn one<'a, C>(self, db: &C) -> Result<Option<E::Model>, DbErr>where C: ConnectionTrait,
Get one Model from the SELECT query
sourcepub async fn all<'a, C>(self, db: &C) -> Result<Vec<E::Model>, DbErr>where
C: ConnectionTrait,
pub async fn all<'a, C>(self, db: &C) -> Result<Vec<E::Model>, DbErr>where C: ConnectionTrait,
Get all Models from the SELECT query
sourcepub 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,
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
sourcepub async fn stream_partial_model<'a: 'b, 'b, C, M>(
self,
db: &'a C
) -> Result<impl Stream<Item = Result<M, DbErr>> + 'b + Send, DbErr>where
C: ConnectionTrait + StreamTrait + Send,
M: PartialModelTrait + Send + 'b,
pub async fn stream_partial_model<'a: 'b, 'b, C, M>( self, db: &'a C ) -> Result<impl Stream<Item = Result<M, DbErr>> + 'b + Send, DbErr>where C: ConnectionTrait + StreamTrait + Send, M: PartialModelTrait + Send + 'b,
Stream the result of the operation with PartialModel
source§impl<E> Select<E>where
E: EntityTrait,
impl<E> Select<E>where E: EntityTrait,
sourcepub fn select_also<F>(self, _: F) -> SelectTwo<E, F>where
F: 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
sourcepub fn select_with<F>(self, _: F) -> SelectTwoMany<E, F>where
F: EntityTrait,
pub fn select_with<F>(self, _: F) -> SelectTwoMany<E, F>where F: EntityTrait,
Makes a SELECT operation in conjunction to another relation
source§impl<E> Select<E>where
E: EntityTrait,
impl<E> Select<E>where E: EntityTrait,
sourcepub fn left_join<R>(self, _: R) -> Selfwhere
R: EntityTrait,
E: Related<R>,
pub fn left_join<R>(self, _: R) -> Selfwhere R: EntityTrait, E: Related<R>,
Left Join with a Related Entity.
sourcepub fn right_join<R>(self, _: R) -> Selfwhere
R: EntityTrait,
E: Related<R>,
pub fn right_join<R>(self, _: R) -> Selfwhere R: EntityTrait, E: Related<R>,
Right Join with a Related Entity.
sourcepub fn inner_join<R>(self, _: R) -> Selfwhere
R: EntityTrait,
E: Related<R>,
pub fn inner_join<R>(self, _: R) -> Selfwhere R: EntityTrait, E: Related<R>,
Inner Join with a Related Entity.
sourcepub fn reverse_join<R>(self, _: R) -> Selfwhere
R: EntityTrait + Related<E>,
pub fn reverse_join<R>(self, _: R) -> Selfwhere R: EntityTrait + Related<E>,
Join with an Entity Related to me.
Left Join with a Related Entity and select both Entity.
Left Join with a Related Entity and select the related Entity as a Vec
sourcepub fn find_also_linked<L, T>(self, l: L) -> SelectTwo<E, T>where
L: Linked<FromEntity = E, ToEntity = T>,
T: EntityTrait,
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.
sourcepub fn find_with_linked<L, T>(self, l: L) -> SelectTwoMany<E, T>where
L: Linked<FromEntity = E, ToEntity = T>,
T: EntityTrait,
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§
source§impl<E, M> CursorTrait for Select<E>where
E: EntityTrait<Model = M>,
M: FromQueryResult + Sized + Send + Sync,
impl<E, M> CursorTrait for Select<E>where E: EntityTrait<Model = M>, M: FromQueryResult + Sized + Send + Sync,
§type Selector = SelectModel<M>
type Selector = SelectModel<M>
source§impl<E> EntityOrSelect<E> for Select<E>where
E: EntityTrait,
impl<E> EntityOrSelect<E> for Select<E>where E: EntityTrait,
source§impl<'db, C, M, E> PaginatorTrait<'db, C> for Select<E>where
C: ConnectionTrait,
E: EntityTrait<Model = M>,
M: FromQueryResult + Sized + Send + Sync + 'db,
impl<'db, C, M, E> PaginatorTrait<'db, C> for Select<E>where C: ConnectionTrait, E: EntityTrait<Model = M>, M: FromQueryResult + Sized + Send + Sync + 'db,
source§impl<E> QueryFilter for Select<E>where
E: EntityTrait,
impl<E> QueryFilter for Select<E>where E: EntityTrait,
type QueryStatement = SelectStatement
source§fn query(&mut self) -> &mut SelectStatement
fn query(&mut self) -> &mut SelectStatement
source§fn filter<F>(self, filter: F) -> Selfwhere
F: IntoCondition,
fn filter<F>(self, filter: F) -> Selfwhere F: IntoCondition,
source§fn belongs_to<M>(self, model: &M) -> Selfwhere
M: ModelTrait,
fn belongs_to<M>(self, model: &M) -> Selfwhere M: ModelTrait,
source§fn belongs_to_tbl_alias<M>(self, model: &M, tbl_alias: &str) -> Selfwhere
M: ModelTrait,
fn belongs_to_tbl_alias<M>(self, model: &M, tbl_alias: &str) -> Selfwhere M: ModelTrait,
source§impl<E> QueryOrder for Select<E>where
E: EntityTrait,
impl<E> QueryOrder for Select<E>where E: EntityTrait,
type QueryStatement = SelectStatement
source§fn query(&mut self) -> &mut SelectStatement
fn query(&mut self) -> &mut SelectStatement
source§fn order_by<C>(self, col: C, ord: Order) -> Selfwhere
C: IntoSimpleExpr,
fn order_by<C>(self, col: C, ord: Order) -> Selfwhere C: IntoSimpleExpr,
source§fn order_by_asc<C>(self, col: C) -> Selfwhere
C: IntoSimpleExpr,
fn order_by_asc<C>(self, col: C) -> Selfwhere C: IntoSimpleExpr,
source§fn order_by_desc<C>(self, col: C) -> Selfwhere
C: IntoSimpleExpr,
fn order_by_desc<C>(self, col: C) -> Selfwhere C: IntoSimpleExpr,
source§impl<E> QuerySelect for Select<E>where
E: EntityTrait,
impl<E> QuerySelect for Select<E>where E: EntityTrait,
type QueryStatement = SelectStatement
source§fn query(&mut self) -> &mut SelectStatement
fn query(&mut self) -> &mut SelectStatement
source§fn select_only(self) -> Self
fn select_only(self) -> Self
source§fn column<C>(self, col: C) -> Selfwhere
C: ColumnTrait,
fn column<C>(self, col: C) -> Selfwhere C: ColumnTrait,
source§fn column_as<C, I>(self, col: C, alias: I) -> Selfwhere
C: IntoSimpleExpr,
I: IntoIdentity,
fn column_as<C, I>(self, col: C, alias: I) -> Selfwhere C: IntoSimpleExpr, I: IntoIdentity,
source§fn columns<C, I>(self, cols: I) -> Selfwhere
C: ColumnTrait,
I: IntoIterator<Item = C>,
fn columns<C, I>(self, cols: I) -> Selfwhere C: ColumnTrait, I: IntoIterator<Item = C>,
source§fn offset<T>(self, offset: T) -> Selfwhere
T: Into<Option<u64>>,
fn offset<T>(self, offset: T) -> Selfwhere T: Into<Option<u64>>,
source§fn limit<T>(self, limit: T) -> Selfwhere
T: Into<Option<u64>>,
fn limit<T>(self, limit: T) -> Selfwhere T: Into<Option<u64>>,
source§fn group_by<C>(self, col: C) -> Selfwhere
C: IntoSimpleExpr,
fn group_by<C>(self, col: C) -> Selfwhere C: IntoSimpleExpr,
source§fn having<F>(self, filter: F) -> Selfwhere
F: IntoCondition,
fn having<F>(self, filter: F) -> Selfwhere F: IntoCondition,
source§fn distinct_on<T, I>(self, cols: I) -> Selfwhere
T: IntoColumnRef,
I: IntoIterator<Item = T>,
fn distinct_on<T, I>(self, cols: I) -> Selfwhere T: IntoColumnRef, I: IntoIterator<Item = T>,
sqlx-postgres
Read moresource§fn join(self, join: JoinType, rel: RelationDef) -> Self
fn join(self, join: JoinType, rel: RelationDef) -> Self
RelationDef
.source§fn join_rev(self, join: JoinType, rel: RelationDef) -> Self
fn join_rev(self, join: JoinType, rel: RelationDef) -> Self
RelationDef
but in reverse direction.
Assume when there exist a relation A to B.
You can reverse join B from A.source§fn join_as<I>(self, join: JoinType, rel: RelationDef, alias: I) -> Selfwhere
I: IntoIden,
fn join_as<I>(self, join: JoinType, rel: RelationDef, alias: I) -> Selfwhere I: IntoIden,
RelationDef
with table alias.source§fn join_as_rev<I>(self, join: JoinType, rel: RelationDef, alias: I) -> Selfwhere
I: IntoIden,
fn join_as_rev<I>(self, join: JoinType, rel: RelationDef, alias: I) -> Selfwhere I: IntoIden,
RelationDef
with table alias but in reverse direction.
Assume when there exist a relation A to B.
You can reverse join B from A.source§fn lock_exclusive(self) -> Self
fn lock_exclusive(self) -> Self
source§fn expr<T>(self, expr: T) -> Selfwhere
T: Into<SelectExpr>,
fn expr<T>(self, expr: T) -> Selfwhere T: Into<SelectExpr>,
source§fn exprs<T, I>(self, exprs: I) -> Selfwhere
T: Into<SelectExpr>,
I: IntoIterator<Item = T>,
fn exprs<T, I>(self, exprs: I) -> Selfwhere T: Into<SelectExpr>, I: IntoIterator<Item = T>,
SelectExpr
. Read more