Trait Expression 

pub trait Expression: Sized {
    type Output: ClickHouseType;

    // Required method
    fn render(&self) -> String;

    // Provided method
    fn is_aggregate(&self) -> bool { ... }
}

Base trait for all expressions

Required Associated Types

type Output: ClickHouseType

The output type of this expression

Required Methods

fn render(&self) -> String

Render the expression to SQL

Provided Methods

fn is_aggregate(&self) -> bool

Whether this is an aggregate expression

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl Expression for Star

type Output = u64

impl Expression for NowExpr

type Output = NaiveDateTime

impl Expression for TodayExpr

type Output = NaiveDate

impl<A: Expression<Output = String>, B: Expression<Output = String>> Expression for ConcatExpr<A, B>

type Output = String

impl<A: Expression, V: Expression> Expression for ArgMaxExpr<A, V>

type Output = <A as Expression>::Output

impl<A: Expression, V: Expression> Expression for ArgMinExpr<A, V>

type Output = <A as Expression>::Output

impl<B: Expression, X: Expression> Expression for PowExpr<B, X>

where B::Output: Numeric, X::Output: Numeric,

type Output = f64

impl<C, T, E> Expression for IfExpr<C, T, E>

where C: Expression<Output = bool>, T: Expression, E: Expression<Output = T::Output>,

type Output = <T as Expression>::Output

impl<C: TypedColumn> Expression for ColumnExpr<C>

type Output = <C as TypedColumn>::Type

impl<C: TypedColumn> Expression for C

type Output = <C as TypedColumn>::Type

impl<E: Expression> Expression for QuantileExpr<E>

where E::Output: Numeric,

type Output = f64

impl<E: Expression> Expression for ToDateExpr<E>

type Output = NaiveDate

impl<E: Expression> Expression for ToDateTimeExpr<E>

type Output = NaiveDateTime

impl<E: Expression> Expression for ToStartOfDayExpr<E>

type Output = NaiveDateTime

impl<E: Expression> Expression for ToStartOfHourExpr<E>

type Output = NaiveDateTime

impl<E: Expression> Expression for ToYYYYMMExpr<E>

type Output = u32

impl<E: Expression> Expression for CityHash64Expr<E>

type Output = u64

impl<E: Expression> Expression for XxHash64Expr<E>

type Output = u64

impl<E: Expression> Expression for AbsExpr<E>

where E::Output: Numeric,

type Output = <E as Expression>::Output

impl<E: Expression> Expression for CeilExpr<E>

where E::Output: Numeric,

type Output = <E as Expression>::Output

impl<E: Expression> Expression for FloorExpr<E>

where E::Output: Numeric,

type Output = <E as Expression>::Output

impl<E: Expression> Expression for RoundExpr<E>

where E::Output: Numeric,

type Output = <E as Expression>::Output

impl<E: Expression> Expression for IsNotNullExpr<E>

type Output = bool

impl<E: Expression> Expression for IsNullExpr<E>

type Output = bool

impl<E: Expression<Output = bool>> Expression for NotExpr<E>

type Output = bool

impl<E: Expression<Output = String>> Expression for LengthExpr<E>

type Output = u64

impl<E: Expression<Output = String>> Expression for LowerExpr<E>

type Output = String

impl<E: Expression<Output = String>> Expression for SubstringExpr<E>

type Output = String

impl<E: Expression<Output = String>> Expression for UpperExpr<E>

type Output = String

impl<E: Expression<Output = String>> Expression for ILikeExpr<E>

type Output = bool

impl<E: Expression<Output = String>> Expression for LikeExpr<E>

type Output = bool

impl<E: Expression, C: Expression<Output = bool>> Expression for GroupArrayIfExpr<E, C>

type Output = Vec<<E as Expression>::Output>

impl<F: AggregateFn, E: Expression> Expression for AggregateExpr<F, E>

type Output = <F as AggregateFn>::Output

impl<L, R, Op> Expression for ArithExpr<L, R, Op>

where L: Expression, R: Expression, Op: ArithmeticOp, L::Output: Numeric, R::Output: Numeric,

type Output = <L as Expression>::Output

impl<L: Expression<Output = bool>, R: Expression<Output = bool>> Expression for AndExpr<L, R>

type Output = bool

impl<L: Expression<Output = bool>, R: Expression<Output = bool>> Expression for OrExpr<L, R>

type Output = bool

impl<L: Expression, R: Expression, Op: ComparisonOp> Expression for CompareExpr<L, R, Op>

type Output = bool

impl<T: ClickHouseType> Expression for Literal<T>

type Output = T

impl<const N: usize, E: Expression> Expression for TopKExpr<N, E>

type Output = Vec<<E as Expression>::Output>