Struct Condition

pub struct Condition {
    pub(crate) negate: bool,
    pub(crate) condition_type: ConditionType,
    pub(crate) conditions: Vec<ConditionExpression>,
}

Represents the value of an Condition::any or Condition::all: a set of disjunctive or conjunctive conditions.

Fields

negate: bool

condition_type: ConditionType

conditions: Vec<ConditionExpression>

Implementations

impl Condition

pub fn add<C>(self, condition: C) -> Self

where C: Into<Condition>,

Add a condition to the set.

If it’s an Condition::any, it will be separated from the others by an " OR " in the query. If it’s an Condition::all, it will be separated by an " AND ".

use sea_query::{tests_cfg::*, *};

let statement = Query::select()
    .column(Glyph::Id)
    .from(Glyph::Table)
    .cond_where(
        Cond::all()
            .add(Expr::col(Glyph::Aspect).eq(0).into_condition().not())
            .add(Expr::col(Glyph::Id).eq(0).into_condition().not()),
    )
    .to_string(PostgresQueryBuilder);
assert_eq!(
    statement,
    r#"SELECT "id" FROM "glyph" WHERE (NOT "aspect" = 0) AND (NOT "id" = 0)"#
);

pub fn add_option<C>(self, other: Option<C>) -> Self

where C: Into<Condition>,

Add an optional condition to the set.

Shorthand for if o.is_some() { self.add(o) }

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Glyph::Image)
    .from(Glyph::Table)
    .cond_where(
        Cond::all()
            .add_option(Some(Expr::col((Glyph::Table, Glyph::Image)).like("A%")))
            .add_option(None::<Expr>),
    )
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `image` FROM `glyph` WHERE `glyph`.`image` LIKE 'A%'"#
);

pub fn any() -> Condition

Create a condition that is true if any of the conditions is true.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .column(Glyph::Image)
    .from(Glyph::Table)
    .cond_where(
        Cond::any()
            .add(Expr::col((Glyph::Table, Glyph::Aspect)).is_in([3, 4]))
            .add(Expr::col((Glyph::Table, Glyph::Image)).like("A%"))
    )
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `image` FROM `glyph` WHERE `glyph`.`aspect` IN (3, 4) OR `glyph`.`image` LIKE 'A%'"#
);

pub fn all() -> Condition

Create a condition that is false if any of the conditions is false.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .column(Glyph::Image)
    .from(Glyph::Table)
    .cond_where(
        Cond::all()
            .add(Expr::col((Glyph::Table, Glyph::Aspect)).is_in([3, 4]))
            .add(Expr::col((Glyph::Table, Glyph::Image)).like("A%"))
    )
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `image` FROM `glyph` WHERE `glyph`.`aspect` IN (3, 4) AND `glyph`.`image` LIKE 'A%'"#
);

pub fn not(self) -> Self

Negates a condition.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Glyph::Image)
    .from(Glyph::Table)
    .cond_where(
        Cond::all()
            .not()
            .add(Expr::col((Glyph::Table, Glyph::Aspect)).is_in([3, 4]))
            .add(Expr::col((Glyph::Table, Glyph::Image)).like("A%"))
    )
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `image` FROM `glyph` WHERE NOT (`glyph`.`aspect` IN (3, 4) AND `glyph`.`image` LIKE 'A%')"#
);

More Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Glyph::Id)
    .cond_where(
        Cond::all()
            .add(
                Cond::all()
                    .not()
                    .add(Expr::val(1).eq(1))
                    .add(Expr::val(2).eq(2)),
            )
            .add(Cond::any().add(Expr::val(3).eq(3)).add(Expr::val(4).eq(4))),
    )
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `id` WHERE (NOT (1 = 1 AND 2 = 2)) AND (3 = 3 OR 4 = 4)"#
);

pub fn is_empty(&self) -> bool

Whether or not any condition has been added

Examples

use sea_query::{tests_cfg::*, *};

let is_empty = Cond::all().is_empty();

assert!(is_empty);

pub fn len(&self) -> usize

How many conditions were added

Examples

use sea_query::{tests_cfg::*, *};

let len = Cond::all().len();

assert_eq!(len, 0);

Trait Implementations

impl Clone for Condition

fn clone(&self) -> Condition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Condition

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

Formats the value using the given formatter.

impl From<Condition> for ConditionExpression

fn from(condition: Condition) -> Self

Converts to this type from the input type.

impl From<Condition> for Expr

fn from(cond: Condition) -> Self

Converts to this type from the input type.

impl From<ConditionExpression> for Condition

fn from(ce: ConditionExpression) -> Self

Converts to this type from the input type.

impl From<Expr> for Condition

fn from(expr: Expr) -> Self

Converts to this type from the input type.

impl PartialEq for Condition

fn eq(&self, other: &Condition) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Condition