AsExpression

diesel::expression

Trait AsExpression

pub trait AsExpression<T>where
    T: SqlType + TypedExpressionType,{
    type Expression: Expression<SqlType = T>;

    // Required method
    fn as_expression(self) -> Self::Expression;
}

Expand description

Converts a type to its representation for use in Diesel’s query builder.

This trait is used directly. Apps should typically use IntoSql instead.

Implementations of this trait will generally do one of 3 things:

Return self for types which are already parts of Diesel’s query builder
Perform some implicit coercion (for example, allowing now to be used as both Timestamp and Timestamptz.
Indicate that the type has data which will be sent separately from the query. This is generally referred as a “bind parameter”. Types which implement ToSql will generally implement AsExpression this way.

This trait could be derived

Required Associated Types§

type Expression: Expression<SqlType = T>

The expression being returned

Required Methods§

fn as_expression(self) -> Self::Expression

Perform the conversion

Implementations on Foreign Types§

impl AsExpression<BigInt> for i64

type Expression = Bound<BigInt, i64>

fn as_expression(self) -> <Self as AsExpression<BigInt>>::Expression

impl AsExpression<Binary> for Vec<u8>

type Expression = Bound<Binary, Vec<u8>>

fn as_expression(self) -> <Self as AsExpression<Binary>>::Expression

impl AsExpression<Bool> for bool

type Expression = Bound<Bool, bool>

fn as_expression(self) -> <Self as AsExpression<Bool>>::Expression

impl AsExpression<Date> for String

type Expression = Bound<Date, String>

fn as_expression(self) -> <Self as AsExpression<Date>>::Expression

impl AsExpression<Double> for f64

type Expression = Bound<Double, f64>

fn as_expression(self) -> <Self as AsExpression<Double>>::Expression

impl AsExpression<Float> for f32

type Expression = Bound<Float, f32>

fn as_expression(self) -> <Self as AsExpression<Float>>::Expression

impl AsExpression<Integer> for i32

type Expression = Bound<Integer, i32>

fn as_expression(self) -> <Self as AsExpression<Integer>>::Expression

impl AsExpression<Nullable<BigInt>> for i64

type Expression = Bound<Nullable<BigInt>, i64>

fn as_expression(self) -> <Self as AsExpression<Nullable<BigInt>>>::Expression

impl AsExpression<Nullable<Binary>> for Vec<u8>

type Expression = Bound<Nullable<Binary>, Vec<u8>>

fn as_expression(self) -> <Self as AsExpression<Nullable<Binary>>>::Expression

impl AsExpression<Nullable<Bool>> for bool

type Expression = Bound<Nullable<Bool>, bool>

fn as_expression(self) -> <Self as AsExpression<Nullable<Bool>>>::Expression

impl AsExpression<Nullable<Date>> for String

type Expression = Bound<Nullable<Date>, String>

fn as_expression(self) -> <Self as AsExpression<Nullable<Date>>>::Expression

impl AsExpression<Nullable<Double>> for f64

type Expression = Bound<Nullable<Double>, f64>

fn as_expression(self) -> <Self as AsExpression<Nullable<Double>>>::Expression

impl AsExpression<Nullable<Float>> for f32

type Expression = Bound<Nullable<Float>, f32>

fn as_expression(self) -> <Self as AsExpression<Nullable<Float>>>::Expression

impl AsExpression<Nullable<Integer>> for i32

type Expression = Bound<Nullable<Integer>, i32>

fn as_expression(self) -> <Self as AsExpression<Nullable<Integer>>>::Expression

impl AsExpression<Nullable<SmallInt>> for i16

type Expression = Bound<Nullable<SmallInt>, i16>

fn as_expression(self) -> <Self as AsExpression<Nullable<SmallInt>>>::Expression

impl AsExpression<Nullable<Text>> for String

type Expression = Bound<Nullable<Text>, String>

fn as_expression(self) -> <Self as AsExpression<Nullable<Text>>>::Expression

impl AsExpression<Nullable<Time>> for String

type Expression = Bound<Nullable<Time>, String>

fn as_expression(self) -> <Self as AsExpression<Nullable<Time>>>::Expression

impl AsExpression<Nullable<Timestamp>> for String

type Expression = Bound<Nullable<Timestamp>, String>

fn as_expression( self, ) -> <Self as AsExpression<Nullable<Timestamp>>>::Expression

impl AsExpression<Nullable<Timestamp>> for SystemTime

type Expression = Bound<Nullable<Timestamp>, SystemTime>

fn as_expression( self, ) -> <Self as AsExpression<Nullable<Timestamp>>>::Expression

impl AsExpression<SmallInt> for i16

type Expression = Bound<SmallInt, i16>

fn as_expression(self) -> <Self as AsExpression<SmallInt>>::Expression

impl AsExpression<Text> for String

type Expression = Bound<Text, String>

fn as_expression(self) -> <Self as AsExpression<Text>>::Expression

impl AsExpression<Time> for String

type Expression = Bound<Time, String>

fn as_expression(self) -> <Self as AsExpression<Time>>::Expression

impl AsExpression<Timestamp> for String

type Expression = Bound<Timestamp, String>

fn as_expression(self) -> <Self as AsExpression<Timestamp>>::Expression

impl AsExpression<Timestamp> for SystemTime

type Expression = Bound<Timestamp, SystemTime>

fn as_expression(self) -> <Self as AsExpression<Timestamp>>::Expression

impl<'expr> AsExpression<BigInt> for &'expr i64

type Expression = Bound<BigInt, &'__expr i64>

fn as_expression(self) -> <Self as AsExpression<BigInt>>::Expression

impl<'expr> AsExpression<Binary> for &'expr Vec<u8>

type Expression = Bound<Binary, &'__expr Vec<u8>>

fn as_expression(self) -> <Self as AsExpression<Binary>>::Expression

impl<'expr> AsExpression<Binary> for &'expr [u8]

type Expression = Bound<Binary, &'__expr [u8]>

fn as_expression(self) -> <Self as AsExpression<Binary>>::Expression

impl<'expr> AsExpression<Bool> for &'expr bool

type Expression = Bound<Bool, &'__expr bool>

fn as_expression(self) -> <Self as AsExpression<Bool>>::Expression

impl<'expr> AsExpression<Date> for &'expr str

type Expression = Bound<Date, &'__expr str>

fn as_expression(self) -> <Self as AsExpression<Date>>::Expression

impl<'expr> AsExpression<Date> for &'expr String

type Expression = Bound<Date, &'__expr String>

fn as_expression(self) -> <Self as AsExpression<Date>>::Expression

impl<'expr> AsExpression<Double> for &'expr f64

type Expression = Bound<Double, &'__expr f64>

fn as_expression(self) -> <Self as AsExpression<Double>>::Expression

impl<'expr> AsExpression<Float> for &'expr f32

type Expression = Bound<Float, &'__expr f32>

fn as_expression(self) -> <Self as AsExpression<Float>>::Expression

impl<'expr> AsExpression<Integer> for &'expr i32

type Expression = Bound<Integer, &'__expr i32>

fn as_expression(self) -> <Self as AsExpression<Integer>>::Expression

impl<'expr> AsExpression<Nullable<BigInt>> for &'expr i64

type Expression = Bound<Nullable<BigInt>, &'__expr i64>

fn as_expression(self) -> <Self as AsExpression<Nullable<BigInt>>>::Expression

impl<'expr> AsExpression<Nullable<Binary>> for &'expr Vec<u8>

type Expression = Bound<Nullable<Binary>, &'__expr Vec<u8>>

fn as_expression(self) -> <Self as AsExpression<Nullable<Binary>>>::Expression

impl<'expr> AsExpression<Nullable<Binary>> for &'expr [u8]

type Expression = Bound<Nullable<Binary>, &'__expr [u8]>

fn as_expression(self) -> <Self as AsExpression<Nullable<Binary>>>::Expression

impl<'expr> AsExpression<Nullable<Bool>> for &'expr bool

type Expression = Bound<Nullable<Bool>, &'__expr bool>

fn as_expression(self) -> <Self as AsExpression<Nullable<Bool>>>::Expression

impl<'expr> AsExpression<Nullable<Date>> for &'expr str

type Expression = Bound<Nullable<Date>, &'__expr str>

fn as_expression(self) -> <Self as AsExpression<Nullable<Date>>>::Expression

impl<'expr> AsExpression<Nullable<Date>> for &'expr String

type Expression = Bound<Nullable<Date>, &'__expr String>

fn as_expression(self) -> <Self as AsExpression<Nullable<Date>>>::Expression

impl<'expr> AsExpression<Nullable<Double>> for &'expr f64

type Expression = Bound<Nullable<Double>, &'__expr f64>

fn as_expression(self) -> <Self as AsExpression<Nullable<Double>>>::Expression

impl<'expr> AsExpression<Nullable<Float>> for &'expr f32

type Expression = Bound<Nullable<Float>, &'__expr f32>

fn as_expression(self) -> <Self as AsExpression<Nullable<Float>>>::Expression

impl<'expr> AsExpression<Nullable<Integer>> for &'expr i32

type Expression = Bound<Nullable<Integer>, &'__expr i32>

fn as_expression(self) -> <Self as AsExpression<Nullable<Integer>>>::Expression

impl<'expr> AsExpression<Nullable<SmallInt>> for &'expr i16

type Expression = Bound<Nullable<SmallInt>, &'__expr i16>

fn as_expression(self) -> <Self as AsExpression<Nullable<SmallInt>>>::Expression

impl<'expr> AsExpression<Nullable<Text>> for &'expr str

type Expression = Bound<Nullable<Text>, &'__expr str>

fn as_expression(self) -> <Self as AsExpression<Nullable<Text>>>::Expression

impl<'expr> AsExpression<Nullable<Text>> for &'expr String

type Expression = Bound<Nullable<Text>, &'__expr String>

fn as_expression(self) -> <Self as AsExpression<Nullable<Text>>>::Expression

impl<'expr> AsExpression<Nullable<Time>> for &'expr str

type Expression = Bound<Nullable<Time>, &'__expr str>

fn as_expression(self) -> <Self as AsExpression<Nullable<Time>>>::Expression

impl<'expr> AsExpression<Nullable<Time>> for &'expr String

type Expression = Bound<Nullable<Time>, &'__expr String>

fn as_expression(self) -> <Self as AsExpression<Nullable<Time>>>::Expression

impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr str

type Expression = Bound<Nullable<Timestamp>, &'__expr str>

fn as_expression( self, ) -> <Self as AsExpression<Nullable<Timestamp>>>::Expression

impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr String

type Expression = Bound<Nullable<Timestamp>, &'__expr String>

fn as_expression( self, ) -> <Self as AsExpression<Nullable<Timestamp>>>::Expression

impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr SystemTime

type Expression = Bound<Nullable<Timestamp>, &'__expr SystemTime>

fn as_expression( self, ) -> <Self as AsExpression<Nullable<Timestamp>>>::Expression

impl<'expr> AsExpression<SmallInt> for &'expr i16

type Expression = Bound<SmallInt, &'__expr i16>

fn as_expression(self) -> <Self as AsExpression<SmallInt>>::Expression

impl<'expr> AsExpression<Text> for &'expr str

type Expression = Bound<Text, &'__expr str>

fn as_expression(self) -> <Self as AsExpression<Text>>::Expression

impl<'expr> AsExpression<Text> for &'expr String

type Expression = Bound<Text, &'__expr String>

fn as_expression(self) -> <Self as AsExpression<Text>>::Expression

impl<'expr> AsExpression<Time> for &'expr str

type Expression = Bound<Time, &'__expr str>

fn as_expression(self) -> <Self as AsExpression<Time>>::Expression

impl<'expr> AsExpression<Time> for &'expr String

type Expression = Bound<Time, &'__expr String>

fn as_expression(self) -> <Self as AsExpression<Time>>::Expression

impl<'expr> AsExpression<Timestamp> for &'expr str

type Expression = Bound<Timestamp, &'__expr str>

fn as_expression(self) -> <Self as AsExpression<Timestamp>>::Expression

impl<'expr> AsExpression<Timestamp> for &'expr String

type Expression = Bound<Timestamp, &'__expr String>

fn as_expression(self) -> <Self as AsExpression<Timestamp>>::Expression

impl<'expr> AsExpression<Timestamp> for &'expr SystemTime

type Expression = Bound<Timestamp, &'__expr SystemTime>

fn as_expression(self) -> <Self as AsExpression<Timestamp>>::Expression

impl<'expr, 'expr2> AsExpression<BigInt> for &'expr2 &'expr i64

type Expression = Bound<BigInt, &'expr2 &'expr i64>

fn as_expression(self) -> <Self as AsExpression<BigInt>>::Expression

impl<'expr, 'expr2> AsExpression<Binary> for &'expr2 &'expr Vec<u8>

type Expression = Bound<Binary, &'expr2 &'expr Vec<u8>>

fn as_expression(self) -> <Self as AsExpression<Binary>>::Expression

impl<'expr, 'expr2> AsExpression<Binary> for &'expr2 &'expr [u8]

type Expression = Bound<Binary, &'expr2 &'expr [u8]>

fn as_expression(self) -> <Self as AsExpression<Binary>>::Expression

impl<'expr, 'expr2> AsExpression<Bool> for &'expr2 &'expr bool

type Expression = Bound<Bool, &'expr2 &'expr bool>

fn as_expression(self) -> <Self as AsExpression<Bool>>::Expression

impl<'expr, 'expr2> AsExpression<Date> for &'expr2 &'expr str

type Expression = Bound<Date, &'expr2 &'expr str>

fn as_expression(self) -> <Self as AsExpression<Date>>::Expression

impl<'expr, 'expr2> AsExpression<Date> for &'expr2 &'expr String

type Expression = Bound<Date, &'expr2 &'expr String>

fn as_expression(self) -> <Self as AsExpression<Date>>::Expression

impl<'expr, 'expr2> AsExpression<Double> for &'expr2 &'expr f64

type Expression = Bound<Double, &'expr2 &'expr f64>

fn as_expression(self) -> <Self as AsExpression<Double>>::Expression

impl<'expr, 'expr2> AsExpression<Float> for &'expr2 &'expr f32

type Expression = Bound<Float, &'expr2 &'expr f32>

fn as_expression(self) -> <Self as AsExpression<Float>>::Expression

impl<'expr, 'expr2> AsExpression<Integer> for &'expr2 &'expr i32

type Expression = Bound<Integer, &'expr2 &'expr i32>

fn as_expression(self) -> <Self as AsExpression<Integer>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<BigInt>> for &'expr2 &'expr i64

type Expression = Bound<Nullable<BigInt>, &'expr2 &'expr i64>

fn as_expression(self) -> <Self as AsExpression<Nullable<BigInt>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<Binary>> for &'expr2 &'expr Vec<u8>

type Expression = Bound<Nullable<Binary>, &'expr2 &'expr Vec<u8>>

fn as_expression(self) -> <Self as AsExpression<Nullable<Binary>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<Binary>> for &'expr2 &'expr [u8]

type Expression = Bound<Nullable<Binary>, &'expr2 &'expr [u8]>

fn as_expression(self) -> <Self as AsExpression<Nullable<Binary>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<Bool>> for &'expr2 &'expr bool

type Expression = Bound<Nullable<Bool>, &'expr2 &'expr bool>

fn as_expression(self) -> <Self as AsExpression<Nullable<Bool>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<Date>> for &'expr2 &'expr str

type Expression = Bound<Nullable<Date>, &'expr2 &'expr str>

fn as_expression(self) -> <Self as AsExpression<Nullable<Date>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<Date>> for &'expr2 &'expr String

type Expression = Bound<Nullable<Date>, &'expr2 &'expr String>

fn as_expression(self) -> <Self as AsExpression<Nullable<Date>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<Double>> for &'expr2 &'expr f64

type Expression = Bound<Nullable<Double>, &'expr2 &'expr f64>

fn as_expression(self) -> <Self as AsExpression<Nullable<Double>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<Float>> for &'expr2 &'expr f32

type Expression = Bound<Nullable<Float>, &'expr2 &'expr f32>

fn as_expression(self) -> <Self as AsExpression<Nullable<Float>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<Integer>> for &'expr2 &'expr i32

type Expression = Bound<Nullable<Integer>, &'expr2 &'expr i32>

fn as_expression(self) -> <Self as AsExpression<Nullable<Integer>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<SmallInt>> for &'expr2 &'expr i16

type Expression = Bound<Nullable<SmallInt>, &'expr2 &'expr i16>

fn as_expression(self) -> <Self as AsExpression<Nullable<SmallInt>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<Text>> for &'expr2 &'expr str

type Expression = Bound<Nullable<Text>, &'expr2 &'expr str>

fn as_expression(self) -> <Self as AsExpression<Nullable<Text>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<Text>> for &'expr2 &'expr String

type Expression = Bound<Nullable<Text>, &'expr2 &'expr String>

fn as_expression(self) -> <Self as AsExpression<Nullable<Text>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<Time>> for &'expr2 &'expr str

type Expression = Bound<Nullable<Time>, &'expr2 &'expr str>

fn as_expression(self) -> <Self as AsExpression<Nullable<Time>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<Time>> for &'expr2 &'expr String

type Expression = Bound<Nullable<Time>, &'expr2 &'expr String>

fn as_expression(self) -> <Self as AsExpression<Nullable<Time>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<Timestamp>> for &'expr2 &'expr str

type Expression = Bound<Nullable<Timestamp>, &'expr2 &'expr str>

fn as_expression( self, ) -> <Self as AsExpression<Nullable<Timestamp>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<Timestamp>> for &'expr2 &'expr String

type Expression = Bound<Nullable<Timestamp>, &'expr2 &'expr String>

fn as_expression( self, ) -> <Self as AsExpression<Nullable<Timestamp>>>::Expression

impl<'expr, 'expr2> AsExpression<Nullable<Timestamp>> for &'expr2 &'expr SystemTime

type Expression = Bound<Nullable<Timestamp>, &'expr2 &'expr SystemTime>

fn as_expression( self, ) -> <Self as AsExpression<Nullable<Timestamp>>>::Expression

impl<'expr, 'expr2> AsExpression<SmallInt> for &'expr2 &'expr i16

type Expression = Bound<SmallInt, &'expr2 &'expr i16>

fn as_expression(self) -> <Self as AsExpression<SmallInt>>::Expression

impl<'expr, 'expr2> AsExpression<Text> for &'expr2 &'expr str

type Expression = Bound<Text, &'expr2 &'expr str>

fn as_expression(self) -> <Self as AsExpression<Text>>::Expression

impl<'expr, 'expr2> AsExpression<Text> for &'expr2 &'expr String

type Expression = Bound<Text, &'expr2 &'expr String>

fn as_expression(self) -> <Self as AsExpression<Text>>::Expression

impl<'expr, 'expr2> AsExpression<Time> for &'expr2 &'expr str

type Expression = Bound<Time, &'expr2 &'expr str>

fn as_expression(self) -> <Self as AsExpression<Time>>::Expression

impl<'expr, 'expr2> AsExpression<Time> for &'expr2 &'expr String

type Expression = Bound<Time, &'expr2 &'expr String>

fn as_expression(self) -> <Self as AsExpression<Time>>::Expression

impl<'expr, 'expr2> AsExpression<Timestamp> for &'expr2 &'expr str

type Expression = Bound<Timestamp, &'expr2 &'expr str>

fn as_expression(self) -> <Self as AsExpression<Timestamp>>::Expression

impl<'expr, 'expr2> AsExpression<Timestamp> for &'expr2 &'expr String

type Expression = Bound<Timestamp, &'expr2 &'expr String>

fn as_expression(self) -> <Self as AsExpression<Timestamp>>::Expression

impl<'expr, 'expr2> AsExpression<Timestamp> for &'expr2 &'expr SystemTime

type Expression = Bound<Timestamp, &'expr2 &'expr SystemTime>

fn as_expression(self) -> <Self as AsExpression<Timestamp>>::Expression

impl<'expr, 'expr2, const N: usize> AsExpression<Binary> for &'expr2 &'expr [u8; N]

type Expression = Bound<Binary, &'expr2 &'expr [u8; N]>

fn as_expression(self) -> <Self as AsExpression<Binary>>::Expression

impl<'expr, 'expr2, const N: usize> AsExpression<Nullable<Binary>> for &'expr2 &'expr [u8; N]

type Expression = Bound<Nullable<Binary>, &'expr2 &'expr [u8; N]>

fn as_expression(self) -> <Self as AsExpression<Nullable<Binary>>>::Expression

impl<'expr, const N: usize> AsExpression<Binary> for &'expr [u8; N]

type Expression = Bound<Binary, &'__expr [u8; N]>

fn as_expression(self) -> <Self as AsExpression<Binary>>::Expression

impl<'expr, const N: usize> AsExpression<Nullable<Binary>> for &'expr [u8; N]

type Expression = Bound<Nullable<Binary>, &'__expr [u8; N]>

fn as_expression(self) -> <Self as AsExpression<Nullable<Binary>>>::Expression

impl<'a, 'b, T, ST> AsExpression<ST> for &'b Cow<'a, T>
where T: 'a + ToOwned + ?Sized, Bound<ST, &'b T>: Expression<SqlType = ST>, ST: SqlType + TypedExpressionType,

type Expression = Bound<ST, &'b T>

fn as_expression(self) -> Self::Expression

impl<'a, T, ST> AsExpression<ST> for Cow<'a, T>
where T: 'a + ToOwned + ?Sized, Bound<ST, Cow<'a, T>>: Expression<SqlType = ST>, ST: SqlType + TypedExpressionType,

type Expression = Bound<ST, Cow<'a, T>>

fn as_expression(self) -> Self::Expression

impl<T, ST> AsExpression<Nullable<ST>> for &Option<T>
where ST: SqlType<IsNull = NotNull>, Nullable<ST>: TypedExpressionType,

type Expression = Bound<Nullable<ST>, &Option<T>>

fn as_expression(self) -> Self::Expression

impl<T, ST> AsExpression<Nullable<ST>> for Option<T>
where ST: SqlType<IsNull = NotNull>, Nullable<ST>: TypedExpressionType,

type Expression = Bound<Nullable<ST>, Option<T>>

fn as_expression(self) -> Self::Expression

impl<const N: usize> AsExpression<Binary> for [u8; N]

type Expression = Bound<Binary, [u8; N]>

fn as_expression(self) -> <Self as AsExpression<Binary>>::Expression

impl<const N: usize> AsExpression<Nullable<Binary>> for [u8; N]

type Expression = Bound<Nullable<Binary>, [u8; N]>

fn as_expression(self) -> <Self as AsExpression<Nullable<Binary>>>::Expression

Implementors§

impl AsExpression<Nullable<Date>> for today

type Expression = Coerce<today, Nullable<Date>>

impl AsExpression<Nullable<Timestamp>> for now

type Expression = Coerce<now, Nullable<Timestamp>>

impl AsExpression<Nullable<Timestamptz>> for now

Available on crate feature sqlite only.

type Expression = Coerce<now, Nullable<Timestamptz>>

impl AsExpression<Timestamptz> for now

Available on crate feature sqlite only.

type Expression = Coerce<now, Timestamptz>

impl<'a> AsExpression<Nullable<Text>> for MigrationVersion<'a>

type Expression = Bound<Nullable<Text>, MigrationVersion<'a>>

impl<'a> AsExpression<Text> for MigrationVersion<'a>

type Expression = Bound<Text, MigrationVersion<'a>>

impl<'a, 'expr> AsExpression<Nullable<Text>> for &'expr MigrationVersion<'a>

type Expression = Bound<Nullable<Text>, &'__expr MigrationVersion<'a>>

impl<'a, 'expr> AsExpression<Text> for &'expr MigrationVersion<'a>

type Expression = Bound<Text, &'__expr MigrationVersion<'a>>

impl<'a, 'expr, 'expr2> AsExpression<Nullable<Text>> for &'expr2 &'expr MigrationVersion<'a>

type Expression = Bound<Nullable<Text>, &'expr2 &'expr MigrationVersion<'a>>

impl<'a, 'expr, 'expr2> AsExpression<Text> for &'expr2 &'expr MigrationVersion<'a>

type Expression = Bound<Text, &'expr2 &'expr MigrationVersion<'a>>

impl<T, ST> AsExpression<ST> for T
where T: Expression<SqlType = ST>, ST: SqlType + TypedExpressionType,

type Expression = T