logo

Trait sea_orm::query::QuerySelect

source · [−]
pub trait QuerySelect: Sized {
    type QueryStatement;


Show 15 methods    fn query(&mut self) -> &mut SelectStatement;

    fn select_only(self) -> Self { ... }
    fn column<C>(self, col: C) -> Self
    where
        C: ColumnTrait,
    { ... }
    fn column_as<C, I>(self, col: C, alias: I) -> Self
    where
        C: IntoSimpleExpr,
        I: IntoIdentity,
    { ... }
    fn offset(self, offset: u64) -> Self { ... }
    fn limit(self, limit: u64) -> Self { ... }
    fn group_by<C>(self, col: C) -> Self
    where
        C: IntoSimpleExpr,
    { ... }
    fn having<F>(self, filter: F) -> Self
    where
        F: IntoCondition,
    { ... }
    fn join(self, join: JoinType, rel: RelationDef) -> Self { ... }
    fn join_rev(self, join: JoinType, rel: RelationDef) -> Self { ... }
    fn join_as<I>(self, join: JoinType, rel: RelationDef, alias: I) -> Self
    where
        I: IntoIden,
    { ... }
    fn join_as_rev<I>(self, join: JoinType, rel: RelationDef, alias: I) -> Self
    where
        I: IntoIden,
    { ... }
    fn lock(self, lock_type: LockType) -> Self { ... }
    fn lock_shared(self) -> Self { ... }
    fn lock_exclusive(self) -> Self { ... }

}
Expand description

Constraints for any type that needs to perform select statements on a Model

Required Associated Types

Required Methods

Add the select SQL statement

Provided Methods

Clear the selection list

Add a select column

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

assert_eq!(
    cake::Entity::find()
        .select_only()
        .column(cake::Column::Name)
        .build(DbBackend::Postgres)
        .to_string(),
    r#"SELECT "cake"."name" FROM "cake""#
);

Add a select column with alias

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

assert_eq!(
    cake::Entity::find()
        .select_only()
        .column_as(cake::Column::Id.count(), "count")
        .build(DbBackend::Postgres)
        .to_string(),
    r#"SELECT COUNT("cake"."id") AS "count" FROM "cake""#
);

Add an offset expression

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

assert_eq!(
    cake::Entity::find()
        .offset(10)
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` OFFSET 10"
);

Add a limit expression

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

assert_eq!(
    cake::Entity::find()
        .limit(10)
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` LIMIT 10"
);

Add a group by column

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

assert_eq!(
    cake::Entity::find()
        .select_only()
        .column(cake::Column::Name)
        .group_by(cake::Column::Name)
        .build(DbBackend::Postgres)
        .to_string(),
    r#"SELECT "cake"."name" FROM "cake" GROUP BY "cake"."name""#
);

Add an AND HAVING expression

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

assert_eq!(
    cake::Entity::find()
        .having(cake::Column::Id.eq(4))
        .having(cake::Column::Id.eq(5))
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` HAVING `cake`.`id` = 4 AND `cake`.`id` = 5"
);

Join via RelationDef.

Join via RelationDef but in reverse direction. Assume when there exist a relation A to B. You can reverse join B from A.

Join via RelationDef with table alias.

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.

Select lock

Select lock shared

Select lock exclusive

Implementors