Struct Expr 

pub struct Expr<T> {
    pub node: ExprNode,
    /* private fields */
}

Fields

node: ExprNode

Implementations

impl<T> Expr<T>

pub fn new(node: ExprNode) -> Self

impl<T> Expr<T>

where T: 'static,

pub fn eq<V>(self, value: V) -> Expr<bool>

where V: ColumnValue<T>,

pub fn eq_col<M2>(self, other: Column<M2, T>) -> Expr<bool>

pub fn ne<V>(self, value: V) -> Expr<bool>

where V: ColumnValue<T>,

pub fn ne_col<M2>(self, other: Column<M2, T>) -> Expr<bool>

pub fn is_distinct_from_col<M2>(self, other: Column<M2, T>) -> Expr<bool>

pub fn is_not_distinct_from_col<M2>(self, other: Column<M2, T>) -> Expr<bool>

pub fn lt<V>(self, value: V) -> Expr<bool>

where V: ColumnValue<T>,

pub fn lt_col<M2>(self, other: Column<M2, T>) -> Expr<bool>

pub fn le<V>(self, value: V) -> Expr<bool>

where V: ColumnValue<T>,

pub fn le_col<M2>(self, other: Column<M2, T>) -> Expr<bool>

pub fn gt<V>(self, value: V) -> Expr<bool>

where V: ColumnValue<T>,

pub fn gt_col<M2>(self, other: Column<M2, T>) -> Expr<bool>

pub fn ge<V>(self, value: V) -> Expr<bool>

where V: ColumnValue<T>,

pub fn ge_col<M2>(self, other: Column<M2, T>) -> Expr<bool>

pub fn between<L, U>(self, low: L, high: U) -> Expr<bool>

where L: ColumnValue<T>, U: ColumnValue<T>,

pub fn like<V>(self, pattern: V) -> Expr<bool>

where V: ColumnValue<T>,

pub fn ilike<V>(self, pattern: V) -> Expr<bool>

where V: ColumnValue<T>,

pub fn is_null(self) -> Expr<bool>

pub fn is_not_null(self) -> Expr<bool>

pub fn in_<I, V>(self, values: I) -> Expr<bool>

where I: IntoIterator<Item = V>, V: ColumnValue<T>,

impl Expr<bool>

pub fn and(self, other: Expr<bool>) -> Expr<bool>

pub fn or(self, other: Expr<bool>) -> Expr<bool>

pub fn not(self) -> Expr<bool>

Trait Implementations

impl<Lhs, RhsExpr> Add<RhsExpr> for Expr<Lhs>

where RhsExpr: ExprOperand, Lhs: SqlAdd<RhsExpr::Value>,

type Output = Expr<<Lhs as SqlAdd<<RhsExpr as ExprOperand>::Value>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Clone> Clone for Expr<T>

fn clone(&self) -> Expr<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Expr<T>

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

Formats the value using the given formatter.

impl<T> ExprOperand for Expr<T>

type Value = T

fn into_operand_expr(self) -> Expr<Self::Value>

impl<T> IntoExpr<T> for Expr<T>

fn into_expr(self) -> Expr<T>

impl<T> IntoOrderExpr for Expr<T>

fn into_order_expr(self) -> OrderExpr

impl<Lhs, RhsExpr> Sub<RhsExpr> for Expr<Lhs>

where RhsExpr: ExprOperand, Lhs: SqlSub<RhsExpr::Value>,

type Output = Expr<<Lhs as SqlSub<<RhsExpr as ExprOperand>::Value>>::Output>

The resulting type after applying the - operator.

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

Performs the - operation.