Trait Expr 

pub trait Expr<'a, V: SQLParam>: ToSQL<'a, V> + ExprSources {
    type SQLType: DataType;
    type Nullable: Nullability;
    type Aggregate: AggregateKind;

    // Provided methods
    fn to_expr_sql(&self) -> SQL<'a, V> { ... }
    fn into_expr_sql(self) -> SQL<'a, V>
       where Self: Sized { ... }
    fn to_condition_sql(&self) -> Option<SQL<'a, V>> { ... }
    fn into_condition_sql(self) -> Option<SQL<'a, V>>
       where Self: Sized { ... }
}

A typed SQL expression.

Columns, Rust literals, SQLExpr values and the results of the functions in this module implement Expr. The associated types describe the result:

• SQLType: the SQL data type, such as the dialect’s integer or text type;
• Nullable: NonNull or Null;
• Aggregate: Scalar or Agg.

V is the dialect’s value type (for example SQLiteValue or PostgresValue), and 'a is the lifetime of borrowed values inside the expression. The table macros implement this trait for generated columns; you rarely implement it yourself.

Examples

A helper that accepts any integer expression:

fn is_adult<'a, E>(age: E) -> impl Expr<'a, Value>
where
    E: Expr<'a, Value, SQLType = Int>,
{
    gt(age, 18)
}

assert_eq!(is_adult(users.age).into_expr_sql().sql(), r#""users"."age" > ?"#);

Required Associated Types

type SQLType: DataType

The SQL data type this expression evaluates to.

type Nullable: Nullability

Whether this expression can be NULL.

type Aggregate: AggregateKind

Whether this is an aggregate (COUNT, SUM) or scalar expression.

Provided Methods

fn to_expr_sql(&self) -> SQL<'a, V>

Renders this value as a scalar expression, borrowing it.

Most expressions use their ToSQL implementation. A few Rust container types, notably byte buffers, need expression-specific rendering because their generic ToSQL form is a comma-separated list.

fn into_expr_sql(self) -> SQL<'a, V>

where Self: Sized,

Renders this value as a scalar expression, consuming it.

fn to_condition_sql(&self) -> Option<SQL<'a, V>>

Renders this value as one element of a ConditionList.

None means the element contributes no condition and is dropped from the combined SQL. Only Option::None does this; every other expression renders through Expr::to_expr_sql.

fn into_condition_sql(self) -> Option<SQL<'a, V>>

where Self: Sized,

Consuming counterpart of Expr::to_condition_sql.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<'a, V, T0, T1, T2, T3, T4, T5, T6, T7> Expr<'a, V> for (T0, T1, T2, T3, T4, T5, T6, T7)

where V: SQLParam + 'a, Self: ConditionList<'a, V> + ToSQL<'a, V>,

type SQLType = Conjunction

type Nullable = <(T0, T1, T2, T3, T4, T5, T6, T7) as ConditionList<'a, V>>::Nullable

type Aggregate = <(T0, T1, T2, T3, T4, T5, T6, T7) as ConditionList<'a, V>>::Aggregate

fn to_expr_sql(&self) -> SQL<'a, V>

fn into_expr_sql(self) -> SQL<'a, V>

impl<'a, V, T0, T1, T2, T3, T4, T5, T6> Expr<'a, V> for (T0, T1, T2, T3, T4, T5, T6)

where V: SQLParam + 'a, Self: ConditionList<'a, V> + ToSQL<'a, V>,

type SQLType = Conjunction

type Nullable = <(T0, T1, T2, T3, T4, T5, T6) as ConditionList<'a, V>>::Nullable

type Aggregate = <(T0, T1, T2, T3, T4, T5, T6) as ConditionList<'a, V>>::Aggregate

fn to_expr_sql(&self) -> SQL<'a, V>

fn into_expr_sql(self) -> SQL<'a, V>

impl<'a, V, T0, T1, T2, T3, T4, T5> Expr<'a, V> for (T0, T1, T2, T3, T4, T5)

where V: SQLParam + 'a, Self: ConditionList<'a, V> + ToSQL<'a, V>,

type SQLType = Conjunction

type Nullable = <(T0, T1, T2, T3, T4, T5) as ConditionList<'a, V>>::Nullable

type Aggregate = <(T0, T1, T2, T3, T4, T5) as ConditionList<'a, V>>::Aggregate

fn to_expr_sql(&self) -> SQL<'a, V>

fn into_expr_sql(self) -> SQL<'a, V>

impl<'a, V, T0, T1, T2, T3, T4> Expr<'a, V> for (T0, T1, T2, T3, T4)

where V: SQLParam + 'a, Self: ConditionList<'a, V> + ToSQL<'a, V>,

type SQLType = Conjunction

type Nullable = <(T0, T1, T2, T3, T4) as ConditionList<'a, V>>::Nullable

type Aggregate = <(T0, T1, T2, T3, T4) as ConditionList<'a, V>>::Aggregate

fn to_expr_sql(&self) -> SQL<'a, V>

fn into_expr_sql(self) -> SQL<'a, V>

impl<'a, V, T0, T1, T2, T3> Expr<'a, V> for (T0, T1, T2, T3)

where V: SQLParam + 'a, Self: ConditionList<'a, V> + ToSQL<'a, V>,

type SQLType = Conjunction

type Nullable = <(T0, T1, T2, T3) as ConditionList<'a, V>>::Nullable

type Aggregate = <(T0, T1, T2, T3) as ConditionList<'a, V>>::Aggregate

fn to_expr_sql(&self) -> SQL<'a, V>

fn into_expr_sql(self) -> SQL<'a, V>

impl<'a, V, T0, T1, T2> Expr<'a, V> for (T0, T1, T2)

where V: SQLParam + 'a, Self: ConditionList<'a, V> + ToSQL<'a, V>,

type SQLType = Conjunction

type Nullable = <(T0, T1, T2) as ConditionList<'a, V>>::Nullable

type Aggregate = <(T0, T1, T2) as ConditionList<'a, V>>::Aggregate

fn to_expr_sql(&self) -> SQL<'a, V>

fn into_expr_sql(self) -> SQL<'a, V>

impl<'a, V, T0, T1> Expr<'a, V> for (T0, T1)

where V: SQLParam + 'a, Self: ConditionList<'a, V> + ToSQL<'a, V>,

type SQLType = Conjunction

type Nullable = <(T0, T1) as ConditionList<'a, V>>::Nullable

type Aggregate = <(T0, T1) as ConditionList<'a, V>>::Aggregate

fn to_expr_sql(&self) -> SQL<'a, V>

fn into_expr_sql(self) -> SQL<'a, V>

impl<'a, V, T0> Expr<'a, V> for (T0,)

where V: SQLParam + 'a, Self: ConditionList<'a, V> + ToSQL<'a, V>,

type SQLType = Conjunction

type Nullable = <(T0,) as ConditionList<'a, V>>::Nullable

type Aggregate = <(T0,) as ConditionList<'a, V>>::Aggregate

fn to_expr_sql(&self) -> SQL<'a, V>

fn into_expr_sql(self) -> SQL<'a, V>

impl<'a, V, T> Expr<'a, V> for &T

where V: SQLParam + 'a, T: Expr<'a, V>, T::Nullable: Nullability,

type SQLType = <T as Expr<'a, V>>::SQLType

type Nullable = <T as Expr<'a, V>>::Nullable

type Aggregate = <T as Expr<'a, V>>::Aggregate

fn to_expr_sql(&self) -> SQL<'a, V>

fn into_expr_sql(self) -> SQL<'a, V>

fn to_condition_sql(&self) -> Option<SQL<'a, V>>

fn into_condition_sql(self) -> Option<SQL<'a, V>>

impl<'a, V, T> Expr<'a, V> for Option<T>

where V: SQLParam + 'a, T: Expr<'a, V>, T::Nullable: Nullability,

fn to_condition_sql(&self) -> Option<SQL<'a, V>>

A missing optional condition contributes nothing to a condition list.

fn into_condition_sql(self) -> Option<SQL<'a, V>>

A missing optional condition contributes nothing to a condition list.

type SQLType = <T as Expr<'a, V>>::SQLType

type Nullable = Null

type Aggregate = <T as Expr<'a, V>>::Aggregate

impl<'a, V, const N: usize> Expr<'a, V> for [char; N]

where V: SQLParam + 'a + From<Self> + From<char> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <[char; N] as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

fn to_expr_sql(&self) -> SQL<'a, V>

fn into_expr_sql(self) -> SQL<'a, V>

impl<'a, V, const N: usize> Expr<'a, V> for [u8; N]

where V: SQLParam + 'a + From<&'a [u8]> + From<Vec<u8>> + From<u8> + Into<Cow<'a, V>>,

type SQLType = <<V as SQLParam>::DialectMarker as DialectTypes>::Bytes

type Nullable = NonNull

type Aggregate = Scalar

fn to_expr_sql(&self) -> SQL<'a, V>

fn into_expr_sql(self) -> SQL<'a, V>

impl<'a, V> Expr<'a, V> for &'a [u8]

where V: SQLParam + 'a + From<&'a [u8]> + From<Vec<u8>> + From<u8> + Into<Cow<'a, V>>,

type SQLType = <<V as SQLParam>::DialectMarker as DialectTypes>::Bytes

type Nullable = NonNull

type Aggregate = Scalar

fn to_expr_sql(&self) -> SQL<'a, V>

fn into_expr_sql(self) -> SQL<'a, V>

impl<'a, V> Expr<'a, V> for &'a str

where V: SQLParam + 'a + From<&'a str> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <&'a str as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

impl<'a, V> Expr<'a, V> for Cow<'a, [u8]>

where V: SQLParam + 'a + From<&'a [u8]> + From<Vec<u8>> + Into<Cow<'a, V>>,

type SQLType = <<V as SQLParam>::DialectMarker as DialectTypes>::Bytes

type Nullable = NonNull

type Aggregate = Scalar

fn to_expr_sql(&self) -> SQL<'a, V>

fn into_expr_sql(self) -> SQL<'a, V>

impl<'a, V> Expr<'a, V> for String

where V: SQLParam + 'a + From<Self> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <String as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

impl<'a, V> Expr<'a, V> for Vec<u8>

where V: SQLParam + 'a + From<&'a [u8]> + From<Vec<u8>> + From<u8> + Into<Cow<'a, V>>,

type SQLType = <<V as SQLParam>::DialectMarker as DialectTypes>::Bytes

type Nullable = NonNull

type Aggregate = Scalar

fn to_expr_sql(&self) -> SQL<'a, V>

fn into_expr_sql(self) -> SQL<'a, V>

impl<'a, V> Expr<'a, V> for bool

where V: SQLParam + 'a + From<Self> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <bool as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

impl<'a, V> Expr<'a, V> for f32

where V: SQLParam + 'a + From<Self> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <f32 as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

impl<'a, V> Expr<'a, V> for f64

where V: SQLParam + 'a + From<Self> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <f64 as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

impl<'a, V> Expr<'a, V> for i8

where V: SQLParam + 'a + From<Self> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <i8 as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

impl<'a, V> Expr<'a, V> for i16

where V: SQLParam + 'a + From<Self> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <i16 as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

impl<'a, V> Expr<'a, V> for i32

where V: SQLParam + 'a + From<Self> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <i32 as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

impl<'a, V> Expr<'a, V> for i64

where V: SQLParam + 'a + From<Self> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <i64 as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

impl<'a, V> Expr<'a, V> for isize

where V: SQLParam + 'a + From<Self> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <isize as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

impl<'a, V> Expr<'a, V> for u8

where V: SQLParam + 'a + From<Self> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <u8 as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

impl<'a, V> Expr<'a, V> for u16

where V: SQLParam + 'a + From<Self> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <u16 as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

impl<'a, V> Expr<'a, V> for u32

where V: SQLParam + 'a + From<Self> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <u32 as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

impl<'a, V> Expr<'a, V> for u64

where V: SQLParam + 'a + From<Self> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <u64 as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

impl<'a, V> Expr<'a, V> for usize

where V: SQLParam + 'a + From<Self> + Into<Cow<'a, V>>, Self: ValueTypeForDialect<V::DialectMarker>,

type SQLType = <usize as ValueTypeForDialect<<V as SQLParam>::DialectMarker>>::SQLType

type Nullable = NonNull

type Aggregate = Scalar

Implementors

impl<'a, V, C> Expr<'a, V> for Excluded<C>

where V: SQLParam + 'a, V::DialectMarker: DialectSupports<Excluded>, C: Expr<'a, V> + SQLColumnInfo,

type SQLType = <C as Expr<'a, V>>::SQLType

type Nullable = <C as Expr<'a, V>>::Nullable

type Aggregate = <C as Expr<'a, V>>::Aggregate

impl<'a, V, E, Name> Expr<'a, V> for NamedExpr<E, Name>

where V: SQLParam + 'a, E: Expr<'a, V>, Name: Tag,

type SQLType = <E as Expr<'a, V>>::SQLType

type Nullable = <E as Expr<'a, V>>::Nullable

type Aggregate = <E as Expr<'a, V>>::Aggregate

impl<'a, V, E> Expr<'a, V> for AliasedExpr<E>

where V: SQLParam + 'a, E: Expr<'a, V>,

type SQLType = <E as Expr<'a, V>>::SQLType

type Nullable = <E as Expr<'a, V>>::Nullable

type Aggregate = <E as Expr<'a, V>>::Aggregate

impl<'a, V, Name, Output> Expr<'a, V> for DerivedField<Name, Output>

where V: SQLParam + 'a, Name: Tag, Output: ProjectionOutput + Expr<'a, V>,

type SQLType = <Output as Expr<'a, V>>::SQLType

type Nullable = <Output as Expr<'a, V>>::Nullable

type Aggregate = Scalar

impl<'a, V: SQLParam + 'a, T: DataType, N: Nullability> Expr<'a, V> for TypedPlaceholder<T, N>

type SQLType = T

type Nullable = N

type Aggregate = Scalar

impl<'a, V: SQLParam + 'a> Expr<'a, V> for Placeholder

type SQLType = Placeholder

type Nullable = NonNull

type Aggregate = Scalar

impl<'a, V: SQLParam, T: DataType, N: Nullability, A: AggregateKind, S> Expr<'a, V> for SQLExpr<'a, V, T, N, A, S>

type SQLType = T

type Nullable = N

type Aggregate = A

impl<'a, V> Expr<'a, V> for SQL<'a, V>

where V: SQLParam + 'a,

type SQLType = <<V as SQLParam>::DialectMarker as DialectTypes>::Any

type Nullable = Null

type Aggregate = Scalar

impl<'a, V> Expr<'a, V> for SQLBytes<'a>

where V: SQLParam + 'a + From<&'a [u8]> + From<Vec<u8>> + Into<Cow<'a, V>>,

type SQLType = <<V as SQLParam>::DialectMarker as DialectTypes>::Bytes

type Nullable = NonNull

type Aggregate = Scalar