Struct CaseStatement 

pub struct CaseStatement { /* private fields */ }

Implementations

impl CaseStatement

pub fn new() -> CaseStatement

Creates a new case statement expression

Examples

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

let query = Query::select()
    .expr_as(
        CaseStatement::new()
            .case(Expr::col((Glyph::Table, Glyph::Aspect)).is_in([2, 4]), true)
            .finally(false),
         "is_even"
    )
    .from(Glyph::Table)
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT (CASE WHEN ("glyph"."aspect" IN (2, 4)) THEN TRUE ELSE FALSE END) AS "is_even" FROM "glyph""#
);

pub fn case<C, T>(self, cond: C, then: T) -> CaseStatement

where C: IntoCondition, T: Into<Expr>,

Adds new CASE WHEN to existing case statement.

Examples

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

let query = Query::select()
    .expr_as(
            Expr::case(
                Expr::col((Glyph::Table, Glyph::Aspect)).gt(0),
                "positive"
             )
            .case(
                Expr::col((Glyph::Table, Glyph::Aspect)).lt(0),
                "negative"
             )
            .finally("zero"),
         "polarity"
    )
    .from(Glyph::Table)
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT (CASE WHEN ("glyph"."aspect" > 0) THEN 'positive' WHEN ("glyph"."aspect" < 0) THEN 'negative' ELSE 'zero' END) AS "polarity" FROM "glyph""#
);

pub fn finally<E>(self, else: E) -> CaseStatement

where E: Into<Expr>,

Ends the case statement with the final ELSE result.

Examples

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

let query = Query::select()
    .expr_as(
        Expr::case(
            Cond::any()
                .add(Expr::col((Character::Table, Character::FontSize)).gt(48))
                .add(Expr::col((Character::Table, Character::SizeW)).gt(500)),
            "large"
        )
        .case(
            Cond::any()
                .add(Expr::col((Character::Table, Character::FontSize)).between(24,48))
                .add(Expr::col((Character::Table, Character::SizeW)).between(300,500)),
            "medium"
        )
        .finally("small"),
        "char_size")
    .from(Character::Table)
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    [
        r#"SELECT"#,
        r#"(CASE WHEN ("character"."font_size" > 48 OR "character"."size_w" > 500) THEN 'large'"#,
        r#"WHEN (("character"."font_size" BETWEEN 24 AND 48) OR ("character"."size_w" BETWEEN 300 AND 500)) THEN 'medium'"#,
        r#"ELSE 'small' END) AS "char_size""#,
        r#"FROM "character""#
    ]
    .join(" ")
);

Trait Implementations

impl Clone for CaseStatement

fn clone(&self) -> CaseStatement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CaseStatement

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

Formats the value using the given formatter.

impl Default for CaseStatement

fn default() -> CaseStatement

Returns the “default value” for a type.

impl Into<Expr> for CaseStatement

fn into(self) -> Expr

Converts this type into the (usually inferred) input type.

impl PartialEq for CaseStatement

fn eq(&self, other: &CaseStatement) -> 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 CaseStatement