Trait AsExpression

Source
pub trait AsExpression<T> {
    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.

§Deriving

This trait can be automatically derived for any type which implements ToSql. The type must be annotated with #[sql_type = "SomeType"]. If that annotation appears multiple times, implementations will be generated for each one of them.

This will generate the following impls:

  • impl AsExpression<SqlType> for YourType
  • impl AsExpression<Nullable<SqlType>> for YourType
  • impl AsExpression<SqlType> for &'a YourType
  • impl AsExpression<Nullable<SqlType>> for &'a YourType
  • impl AsExpression<SqlType> for &'a &'b YourType
  • impl AsExpression<Nullable<SqlType>> for &'a &'b YourType

If your type is unsized, you can specify this by adding the annotation #[diesel(not_sized)]. This will skip the impls for non-reference types.

Required Associated Types§

Source

type Expression: Expression<SqlType = T>

The expression being returned

Required Methods§

Source

fn as_expression(self) -> Self::Expression

Perform the conversion

Implementations on Foreign Types§

Source§

impl AsExpression<Json> for Value

Source§

impl AsExpression<Jsonb> for Value

Source§

impl AsExpression<Oid> for u32

Source§

impl AsExpression<Timestamptz> for NaiveDateTime

Source§

impl AsExpression<Uuid> for Uuid

Source§

impl AsExpression<Uuid> for Uuid

Source§

impl AsExpression<BigInt> for i64

Source§

impl AsExpression<Binary> for Vec<u8>

Source§

impl AsExpression<Bool> for bool

Source§

impl AsExpression<Date> for NaiveDate

Source§

impl AsExpression<Double> for f64

Source§

impl AsExpression<Float> for f32

Source§

impl AsExpression<Integer> for i32

Source§

impl AsExpression<Nullable<Json>> for Value

Source§

impl AsExpression<Nullable<Jsonb>> for Value

Source§

impl AsExpression<Nullable<Oid>> for u32

Source§

impl AsExpression<Nullable<Timestamptz>> for NaiveDateTime

Source§

impl AsExpression<Nullable<Uuid>> for Uuid

Source§

impl AsExpression<Nullable<Uuid>> for Uuid

Source§

impl AsExpression<Nullable<BigInt>> for i64

Source§

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

Source§

impl AsExpression<Nullable<Bool>> for bool

Source§

impl AsExpression<Nullable<Date>> for NaiveDate

Source§

impl AsExpression<Nullable<Double>> for f64

Source§

impl AsExpression<Nullable<Float>> for f32

Source§

impl AsExpression<Nullable<Integer>> for i32

Source§

impl AsExpression<Nullable<SmallInt>> for i16

Source§

impl AsExpression<Nullable<Text>> for String

Source§

impl AsExpression<Nullable<Time>> for NaiveTime

Source§

impl AsExpression<Nullable<Timestamp>> for NaiveDateTime

Source§

impl AsExpression<Nullable<Timestamp>> for SystemTime

Source§

impl AsExpression<SmallInt> for i16

Source§

impl AsExpression<Text> for String

Source§

impl AsExpression<Time> for NaiveTime

Source§

impl AsExpression<Timestamp> for NaiveDateTime

Source§

impl AsExpression<Timestamp> for SystemTime

Source§

impl<'a, 'b, ST, T> AsExpression<Array<ST>> for &'a &'b [T]

Source§

type Expression = Bound<Array<ST>, &'a &'b [T]>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'a, 'b, ST, T> AsExpression<Array<ST>> for &'a &'b Vec<T>

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'a, 'b, ST, T> AsExpression<Array<ST>> for &'a [T]

Source§

type Expression = Bound<Array<ST>, &'a [T]>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'a, 'b, ST, T> AsExpression<Array<ST>> for &'a Vec<T>

Source§

type Expression = Bound<Array<ST>, &'a Vec<T>>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'a, 'b, ST, T> AsExpression<Array<ST>> for Vec<T>

Source§

type Expression = Bound<Array<ST>, Vec<T>>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'a, 'b, ST, T> AsExpression<Nullable<Array<ST>>> for &'a &'b [T]

Source§

type Expression = Bound<Nullable<Array<ST>>, &'a &'b [T]>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'a, 'b, ST, T> AsExpression<Nullable<Array<ST>>> for &'a &'b Vec<T>

Source§

type Expression = Bound<Nullable<Array<ST>>, &'a &'b Vec<T>>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'a, 'b, ST, T> AsExpression<Nullable<Array<ST>>> for &'a [T]

Source§

type Expression = Bound<Nullable<Array<ST>>, &'a [T]>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'a, 'b, ST, T> AsExpression<Nullable<Array<ST>>> for &'a Vec<T>

Source§

type Expression = Bound<Nullable<Array<ST>>, &'a Vec<T>>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'a, 'b, ST, T> AsExpression<Nullable<Array<ST>>> for Vec<T>

Source§

type Expression = Bound<Nullable<Array<ST>>, Vec<T>>

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'a, ST, T> AsExpression<Range<ST>> for &'a (Bound<T>, Bound<T>)

Source§

type Expression = Bound<Range<ST>, &'a (Bound<T>, Bound<T>)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'a, ST, T> AsExpression<Nullable<Range<ST>>> for &'a (Bound<T>, Bound<T>)

Source§

type Expression = Bound<Nullable<Range<ST>>, &'a (Bound<T>, Bound<T>)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'a, T, ST> AsExpression<Nullable<ST>> for &'a Option<T>
where ST: NotNull,

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr2, 'expr> AsExpression<Json> for &'expr2 &'expr Value

Source§

type Expression = Bound<Json, &'expr2 &'expr Value>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr2, 'expr> AsExpression<Jsonb> for &'expr2 &'expr Value

Source§

type Expression = Bound<Jsonb, &'expr2 &'expr Value>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr2, 'expr> AsExpression<Oid> for &'expr2 &'expr u32

Source§

type Expression = Bound<Oid, &'expr2 &'expr u32>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr2, 'expr> AsExpression<Timestamptz> for &'expr2 &'expr NaiveDateTime

Source§

type Expression = Bound<Timestamptz, &'expr2 &'expr NaiveDateTime>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr2, 'expr> AsExpression<Uuid> for &'expr2 &'expr Uuid

Source§

type Expression = Bound<Uuid, &'expr2 &'expr Uuid>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr2, 'expr> AsExpression<Uuid> for &'expr2 &'expr Uuid

Source§

type Expression = Bound<Uuid, &'expr2 &'expr Uuid>

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr2, 'expr> AsExpression<Nullable<Json>> for &'expr2 &'expr Value

Source§

type Expression = Bound<Nullable<Json>, &'expr2 &'expr Value>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr2, 'expr> AsExpression<Nullable<Jsonb>> for &'expr2 &'expr Value

Source§

type Expression = Bound<Nullable<Jsonb>, &'expr2 &'expr Value>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr2, 'expr> AsExpression<Nullable<Oid>> for &'expr2 &'expr u32

Source§

type Expression = Bound<Nullable<Oid>, &'expr2 &'expr u32>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr2, 'expr> AsExpression<Nullable<Timestamptz>> for &'expr2 &'expr NaiveDateTime

Source§

impl<'expr2, 'expr> AsExpression<Nullable<Uuid>> for &'expr2 &'expr Uuid

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr2, 'expr> AsExpression<Nullable<Uuid>> for &'expr2 &'expr Uuid

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr2, 'expr, Tz: TimeZone> AsExpression<Timestamptz> for &'expr2 &'expr DateTime<Tz>

Source§

type Expression = Bound<Timestamptz, &'expr2 &'expr DateTime<Tz>>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr2, 'expr, Tz: TimeZone> AsExpression<Nullable<Timestamptz>> for &'expr2 &'expr DateTime<Tz>

Source§

type Expression = Bound<Nullable<Timestamptz>, &'expr2 &'expr DateTime<Tz>>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr> AsExpression<Json> for &'expr Value

Source§

type Expression = Bound<Json, &'expr Value>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr> AsExpression<Jsonb> for &'expr Value

Source§

type Expression = Bound<Jsonb, &'expr Value>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr> AsExpression<Oid> for &'expr u32

Source§

type Expression = Bound<Oid, &'expr u32>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr> AsExpression<Timestamptz> for &'expr NaiveDateTime

Source§

impl<'expr> AsExpression<Uuid> for &'expr Uuid

Source§

type Expression = Bound<Uuid, &'expr Uuid>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr> AsExpression<Uuid> for &'expr Uuid

Source§

type Expression = Bound<Uuid, &'expr Uuid>

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

type Expression = Bound<Date, &'expr NaiveDate>

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr> AsExpression<Nullable<Json>> for &'expr Value

Source§

type Expression = Bound<Nullable<Json>, &'expr Value>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr> AsExpression<Nullable<Jsonb>> for &'expr Value

Source§

type Expression = Bound<Nullable<Jsonb>, &'expr Value>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr> AsExpression<Nullable<Oid>> for &'expr u32

Source§

type Expression = Bound<Nullable<Oid>, &'expr u32>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr> AsExpression<Nullable<Timestamptz>> for &'expr NaiveDateTime

Source§

impl<'expr> AsExpression<Nullable<Uuid>> for &'expr Uuid

Source§

type Expression = Bound<Nullable<Uuid>, &'expr Uuid>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr> AsExpression<Nullable<Uuid>> for &'expr Uuid

Source§

type Expression = Bound<Nullable<Uuid>, &'expr Uuid>

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

type Expression = Bound<Time, &'expr NaiveTime>

Source§

fn as_expression(self) -> Self::Expression

Source§

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

Source§

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

Source§

impl<'expr, Tz: TimeZone> AsExpression<Timestamptz> for &'expr DateTime<Tz>

Source§

type Expression = Bound<Timestamptz, &'expr DateTime<Tz>>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<'expr, Tz: TimeZone> AsExpression<Nullable<Timestamptz>> for &'expr DateTime<Tz>

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, <U as AsExpression<SU>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, <U as AsExpression<SU>>::Expression, <V as AsExpression<SV>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, <U as AsExpression<SU>>::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, <U as AsExpression<SU>>::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, <U as AsExpression<SU>>::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, <U as AsExpression<SU>>::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression, <AD as AsExpression<SAD>>::Expression, <AE as AsExpression<SAE>>::Expression, <AF as AsExpression<SAF>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, <U as AsExpression<SU>>::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression, <AD as AsExpression<SAD>>::Expression, <AE as AsExpression<SAE>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, <U as AsExpression<SU>>::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression, <AD as AsExpression<SAD>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, <U as AsExpression<SU>>::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, <U as AsExpression<SU>>::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, <U as AsExpression<SU>>::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, <U as AsExpression<SU>>::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression, <Q as AsExpression<SQ>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, <P as AsExpression<SP>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>> for (A, B, C, D, E, F, G, H, I, J, K, L)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>> for (A, B, C, D, E, F, G, H, I, J, K)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>> for (A, B, C, D, E, F, G, H, I, J)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression, <J as AsExpression<SJ>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>> for (A, B, C, D, E, F, G, H, I)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, <I as AsExpression<SI>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>> for (A, B, C, D, E, F, G, H)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG)>> for (A, B, C, D, E, F, G)

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF> AsExpression<Record<(SA, SB, SC, SD, SE, SF)>> for (A, B, C, D, E, F)
where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF)>>,

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, E, SA, SB, SC, SD, SE> AsExpression<Record<(SA, SB, SC, SD, SE)>> for (A, B, C, D, E)
where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE)>>,

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, D, SA, SB, SC, SD> AsExpression<Record<(SA, SB, SC, SD)>> for (A, B, C, D)
where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD)>>,

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, C, SA, SB, SC> AsExpression<Record<(SA, SB, SC)>> for (A, B, C)
where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, PgTuple<(A::Expression, B::Expression, C::Expression)>: Expression<SqlType = Record<(SA, SB, SC)>>,

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, B, SA, SB> AsExpression<Record<(SA, SB)>> for (A, B)
where A: AsExpression<SA>, B: AsExpression<SB>, PgTuple<(A::Expression, B::Expression)>: Expression<SqlType = Record<(SA, SB)>>,

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<A, SA> AsExpression<Record<(SA,)>> for (A,)
where A: AsExpression<SA>, PgTuple<(A::Expression,)>: Expression<SqlType = Record<(SA,)>>,

Source§

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression,)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<ST, T> AsExpression<Range<ST>> for (Bound<T>, Bound<T>)

Source§

type Expression = Bound<Range<ST>, (Bound<T>, Bound<T>)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<ST, T> AsExpression<Nullable<Range<ST>>> for (Bound<T>, Bound<T>)

Source§

type Expression = Bound<Nullable<Range<ST>>, (Bound<T>, Bound<T>)>

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<T, ST> AsExpression<Nullable<ST>> for Option<T>
where ST: NotNull,

Source§

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

Source§

fn as_expression(self) -> Self::Expression

Source§

impl<Tz: TimeZone> AsExpression<Timestamptz> for DateTime<Tz>

Source§

impl<Tz: TimeZone> AsExpression<Nullable<Timestamptz>> for DateTime<Tz>

Implementors§

Source§

impl AsExpression<Money> for PgMoney

Source§

impl AsExpression<Timestamptz> for now

Source§

impl AsExpression<Timestamptz> for PgTimestamp

Source§

impl AsExpression<Date> for PgDate

Source§

impl AsExpression<Interval> for PgInterval

Source§

impl AsExpression<Nullable<Money>> for PgMoney

Source§

impl AsExpression<Nullable<Timestamptz>> for now

Source§

impl AsExpression<Nullable<Timestamptz>> for PgTimestamp

Source§

impl AsExpression<Nullable<Date>> for PgDate

Source§

impl AsExpression<Nullable<Interval>> for PgInterval

Source§

impl AsExpression<Nullable<Numeric>> for PgNumeric

Source§

impl AsExpression<Nullable<Time>> for PgTime

Source§

impl AsExpression<Nullable<Timestamp>> for now

Source§

impl AsExpression<Nullable<Timestamp>> for PgTimestamp

Source§

impl AsExpression<Numeric> for PgNumeric

Source§

impl AsExpression<Time> for PgTime

Source§

impl AsExpression<Timestamp> for PgTimestamp

Source§

impl<'expr2, 'expr> AsExpression<Money> for &'expr2 &'expr PgMoney

Source§

type Expression = Bound<Money, &'expr2 &'expr PgMoney>

Source§

impl<'expr2, 'expr> AsExpression<Timestamptz> for &'expr2 &'expr PgTimestamp

Source§

type Expression = Bound<Timestamptz, &'expr2 &'expr PgTimestamp>

Source§

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

Source§

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

Source§

impl<'expr2, 'expr> AsExpression<Interval> for &'expr2 &'expr PgInterval

Source§

type Expression = Bound<Interval, &'expr2 &'expr PgInterval>

Source§

impl<'expr2, 'expr> AsExpression<Nullable<Money>> for &'expr2 &'expr PgMoney

Source§

type Expression = Bound<Nullable<Money>, &'expr2 &'expr PgMoney>

Source§

impl<'expr2, 'expr> AsExpression<Nullable<Timestamptz>> for &'expr2 &'expr PgTimestamp

Source§

type Expression = Bound<Nullable<Timestamptz>, &'expr2 &'expr PgTimestamp>

Source§

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

Source§

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

Source§

impl<'expr2, 'expr> AsExpression<Nullable<Interval>> for &'expr2 &'expr PgInterval

Source§

type Expression = Bound<Nullable<Interval>, &'expr2 &'expr PgInterval>

Source§

impl<'expr2, 'expr> AsExpression<Nullable<Numeric>> for &'expr2 &'expr PgNumeric

Source§

type Expression = Bound<Nullable<Numeric>, &'expr2 &'expr PgNumeric>

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<'expr2, 'expr> AsExpression<Numeric> for &'expr2 &'expr PgNumeric

Source§

type Expression = Bound<Numeric, &'expr2 &'expr PgNumeric>

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<'expr> AsExpression<Money> for &'expr PgMoney

Source§

type Expression = Bound<Money, &'expr PgMoney>

Source§

impl<'expr> AsExpression<Timestamptz> for &'expr PgTimestamp

Source§

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

Source§

type Expression = Bound<Date, &'expr PgDate>

Source§

impl<'expr> AsExpression<Interval> for &'expr PgInterval

Source§

type Expression = Bound<Interval, &'expr PgInterval>

Source§

impl<'expr> AsExpression<Nullable<Money>> for &'expr PgMoney

Source§

type Expression = Bound<Nullable<Money>, &'expr PgMoney>

Source§

impl<'expr> AsExpression<Nullable<Timestamptz>> for &'expr PgTimestamp

Source§

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

Source§

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

Source§

impl<'expr> AsExpression<Nullable<Interval>> for &'expr PgInterval

Source§

impl<'expr> AsExpression<Nullable<Numeric>> for &'expr PgNumeric

Source§

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

Source§

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

Source§

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

Source§

impl<'expr> AsExpression<Numeric> for &'expr PgNumeric

Source§

type Expression = Bound<Numeric, &'expr PgNumeric>

Source§

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

Source§

type Expression = Bound<Time, &'expr PgTime>

Source§

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

Source§

impl<T: Expression> AsExpression<<T as Expression>::SqlType> for T