Type Alias case_when

pub type case_when<C, T, ST = <T as Expression>::SqlType> = CaseWhen<CaseWhenConditionsLeaf<Grouped<C>, Grouped<AsExprOf<T, ST>>>, NoElseExpression>;

The return type of case_when()

Aliased Type

struct case_when<C, T, ST = <T as Expression>::SqlType> { /* private fields */ }

Implementations

impl<Whens, E> CaseWhen<Whens, E>

pub fn when<C, T>(self, condition: C, if_true: T) -> When<Self, C, T>

where Self: CaseWhenTypesExtractor<Whens = Whens, Else = E>, C: Expression, <C as Expression>::SqlType: BoolOrNullableBool, T: AsExpression<<Self as CaseWhenTypesExtractor>::OutputExpressionSpecifiedSqlType>,

Add an additional WHEN ... THEN ... branch to the CASE expression

See the case_when documentation for more details.

impl<Whens> CaseWhen<Whens, NoElseExpression>

pub fn otherwise<E>(self, if_no_other_branch_matched: E) -> Otherwise<Self, E>

where Self: CaseWhenTypesExtractor<Whens = Whens, Else = NoElseExpression>, E: AsExpression<<Self as CaseWhenTypesExtractor>::OutputExpressionSpecifiedSqlType>,

Sets the ELSE branch of the CASE expression

It is named this way because else is a reserved keyword in Rust

See the case_when documentation for more details.

Trait Implementations

impl<Whens, E, __Rhs> Add<__Rhs> for CaseWhen<Whens, E>

where Self: Expression, <Self as Expression>::SqlType: Add, <<Self as Expression>::SqlType as Add>::Rhs: SqlType + SingleValue, __Rhs: AsExpression<<<Self as Expression>::SqlType as Add>::Rhs>,

type Output = Add<CaseWhen<Whens, E>, <__Rhs as AsExpression<<<CaseWhen<Whens, E> as Expression>::SqlType as Add>::Rhs>>::Expression>

The resulting type after applying the + operator.

fn add(self, rhs: __Rhs) -> Self::Output

Performs the + operation.

impl<Whens: Clone, E: Clone> Clone for CaseWhen<Whens, E>

fn clone(&self) -> CaseWhen<Whens, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Whens: Debug, E: Debug> Debug for CaseWhen<Whens, E>

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

Formats the value using the given formatter.

impl<Whens, E, __Rhs> Div<__Rhs> for CaseWhen<Whens, E>

where Self: Expression, <Self as Expression>::SqlType: Div, <<Self as Expression>::SqlType as Div>::Rhs: SqlType + SingleValue, __Rhs: AsExpression<<<Self as Expression>::SqlType as Div>::Rhs>,

type Output = Div<CaseWhen<Whens, E>, <__Rhs as AsExpression<<<CaseWhen<Whens, E> as Expression>::SqlType as Div>::Rhs>>::Expression>

The resulting type after applying the / operator.

fn div(self, rhs: __Rhs) -> Self::Output

Performs the / operation.

impl<W, T> Expression for CaseWhen<CaseWhenConditionsLeaf<W, T>, NoElseExpression>

where W: Expression, <W as Expression>::SqlType: BoolOrNullableBool, T: Expression, <T as Expression>::SqlType: IntoNullable, <<T as Expression>::SqlType as IntoNullable>::Nullable: SqlType + TypedExpressionType,

type SqlType = <<T as Expression>::SqlType as IntoNullable>::Nullable

The type that this expression represents in SQL

impl<Whens, E, __Rhs> Mul<__Rhs> for CaseWhen<Whens, E>

where Self: Expression, <Self as Expression>::SqlType: Mul, <<Self as Expression>::SqlType as Mul>::Rhs: SqlType + SingleValue, __Rhs: AsExpression<<<Self as Expression>::SqlType as Mul>::Rhs>,

type Output = Mul<CaseWhen<Whens, E>, <__Rhs as AsExpression<<<CaseWhen<Whens, E> as Expression>::SqlType as Mul>::Rhs>>::Expression>

The resulting type after applying the * operator.

fn mul(self, rhs: __Rhs) -> Self::Output

Performs the * operation.

impl<Whens, E, DB> QueryFragment<DB> for CaseWhen<Whens, E>

where DB: Backend, Whens: QueryFragment<DB>, E: QueryFragment<DB>,

fn walk_ast<'b>(&'b self, out: AstPass<'_, 'b, DB>) -> QueryResult<()>

Walk over this QueryFragment for all passes.

fn to_sql(&self, out: &mut DB::QueryBuilder, backend: &DB) -> QueryResult<()>

Converts this QueryFragment to its SQL representation.

fn collect_binds<'b>( &'b self, out: &mut DB::BindCollector<'b>, metadata_lookup: &mut DB::MetadataLookup, backend: &'b DB, ) -> QueryResult<()>

Serializes all bind parameters in this query.

fn is_safe_to_cache_prepared(&self, backend: &DB) -> QueryResult<bool>

Is this query safe to store in the prepared statement cache?

fn is_noop(&self, backend: &DB) -> QueryResult<bool>

Does walking this AST have any effect?

impl<Whens: QueryId, E: QueryId> QueryId for CaseWhen<Whens, E>

const HAS_STATIC_QUERY_ID: bool = _

Can the SQL generated by Self be uniquely identified by its type?

type QueryId = CaseWhen<<Whens as QueryId>::QueryId, <E as QueryId>::QueryId>

A type which uniquely represents Self in a SQL query.

fn query_id() -> Option<TypeId>

Returns the type id of Self::QueryId if Self::HAS_STATIC_QUERY_ID. Returns None otherwise.

impl<Whens, E, __Rhs> Sub<__Rhs> for CaseWhen<Whens, E>

where Self: Expression, <Self as Expression>::SqlType: Sub, <<Self as Expression>::SqlType as Sub>::Rhs: SqlType + SingleValue, __Rhs: AsExpression<<<Self as Expression>::SqlType as Sub>::Rhs>,

type Output = Sub<CaseWhen<Whens, E>, <__Rhs as AsExpression<<<CaseWhen<Whens, E> as Expression>::SqlType as Sub>::Rhs>>::Expression>

The resulting type after applying the - operator.

fn sub(self, rhs: __Rhs) -> Self::Output

Performs the - operation.

impl<Whens, E, __GroupByClause> ValidGrouping<__GroupByClause> for CaseWhen<Whens, E>

where Whens: ValidGrouping<__GroupByClause>, E: ValidGrouping<__GroupByClause>, Whens::IsAggregate: MixedAggregates<E::IsAggregate>,

type IsAggregate = <<Whens as ValidGrouping<__GroupByClause>>::IsAggregate as MixedAggregates<<E as ValidGrouping<__GroupByClause>>::IsAggregate>>::Output

Is this expression aggregate?

impl<W, T, QS> AppearsOnTable<QS> for CaseWhen<CaseWhenConditionsLeaf<W, T>, NoElseExpression>

where CaseWhen<CaseWhenConditionsLeaf<W, T>, NoElseExpression>: Expression, W: AppearsOnTable<QS>, T: AppearsOnTable<QS>,

impl<Whens: Copy, E: Copy> Copy for CaseWhen<Whens, E>

impl<W, T, QS> SelectableExpression<QS> for CaseWhen<CaseWhenConditionsLeaf<W, T>, NoElseExpression>

where CaseWhen<CaseWhenConditionsLeaf<W, T>, NoElseExpression>: AppearsOnTable<QS>, W: SelectableExpression<QS>, T: SelectableExpression<QS>,