Trait sea_orm::entity::prelude::QueryFilter

source · [−]

pub trait QueryFilter: Sized {
    type QueryStatement: ConditionalStatement;
    fn query(&mut self) -> &mut Self::QueryStatement;

    fn filter<F>(self, filter: F) -> Self
    where
        F: IntoCondition,
    { ... }
    fn belongs_to<M>(self, model: &M) -> Self
    where
        M: ModelTrait,
    { ... }
    fn belongs_to_tbl_alias<M>(self, model: &M, tbl_alias: &str) -> Self
    where
        M: ModelTrait,
    { ... }
}

Expand description

Perform a FILTER opertation on a statement

Associated Types

source

type QueryStatement: ConditionalStatement

Required methods

source

fn query(&mut self) -> &mut Self::QueryStatement

Add the query to perform a FILTER on

Provided methods

source

fn filter<F>(self, filter: F) -> Self where
F: IntoCondition,

Add an AND WHERE expression

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

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

Add a condition tree.

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

assert_eq!(
    cake::Entity::find()
        .filter(
            Condition::any()
                .add(cake::Column::Id.eq(4))
                .add(cake::Column::Id.eq(5))
        )
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`id` = 4 OR `cake`.`id` = 5"
);

Add a runtime-built condition tree.

use sea_orm::{entity::*, query::*, tests_cfg::cake, DbBackend};
struct Input {
    name: Option<String>,
}
let input = Input {
    name: Some("cheese".to_owned()),
};

let mut conditions = Condition::all();
if let Some(name) = input.name {
    conditions = conditions.add(cake::Column::Name.contains(&name));
}

assert_eq!(
    cake::Entity::find()
        .filter(conditions)
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE '%cheese%'"
);

Add a runtime-built condition tree, functional-way.

use sea_orm::{entity::*, query::*, tests_cfg::cake, DbBackend};
struct Input {
    name: Option<String>,
}
let input = Input {
    name: Some("cheese".to_owned()),
};

assert_eq!(
    cake::Entity::find()
        .filter(
            Condition::all().add_option(input.name.map(|n| cake::Column::Name.contains(&n)))
        )
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE '%cheese%'"
);

A slightly more complex example.

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

assert_eq!(
    cake::Entity::find()
        .filter(
            Condition::all()
                .add(
                    Condition::all()
                        .not()
                        .add(Expr::val(1).eq(1))
                        .add(Expr::val(2).eq(2))
                )
                .add(
                    Condition::any()
                        .add(Expr::val(3).eq(3))
                        .add(Expr::val(4).eq(4))
                )
        )
        .build(DbBackend::Postgres)
        .to_string(),
    r#"SELECT "cake"."id", "cake"."name" FROM "cake" WHERE (NOT (1 = 1 AND 2 = 2)) AND (3 = 3 OR 4 = 4)"#
);

Use a sea_query expression

use sea_orm::{entity::*, query::*, sea_query::Expr, tests_cfg::fruit, DbBackend};

assert_eq!(
    fruit::Entity::find()
        .filter(Expr::col(fruit::Column::CakeId).is_null())
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit` WHERE `cake_id` IS NULL"
);