pub struct Record<ST: 'static>(_);
postgres_backend
only.Expand description
The Record
(a.k.a. tuple) SQL type.
ToSql
impls
- Any tuple which can be serialized to each of the elements (note: There are major caveats, see the section below)
FromSql
impls
- Any tuple which can be deserialized from each of the elements.
Caveats about serialization
Typically in the documentation for SQL types, we use “FromSql
impls”
as a shorthand for “Rust types that you can use to represent this type”.
For every other type, that means there is specifically an implementation
of the FromSql
trait.
However, PostgreSQL does not support transmission of anonymous record
types as bind parameters. It only supports transmission for named
composite types. For this reason, if you tried to do
int_tuple_col.eq((1, 2))
, we will generate the SQL int_tuple_col = ($1, $2)
rather than int_tuple_col = $1
as we would for anything
else.
This should not be visible during normal usage. The only time this would
affect you is if you were attempting to use sql_query
with tuples.
Your code would not compile in that case, as the ToSql
trait itself is
not implemented.
You can implement ToSql
for named composite types. See WriteTuple
for details.
Trait Implementations
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
ST9: SqlType + TypedExpressionType,
ST10: SqlType + TypedExpressionType,
ST11: SqlType + TypedExpressionType,
ST12: SqlType + TypedExpressionType,
ST13: SqlType + TypedExpressionType,
ST14: SqlType + TypedExpressionType,
ST15: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
T9: AsExpression<ST9>,
T10: AsExpression<ST10>,
T11: AsExpression<ST11>,
T12: AsExpression<ST12>,
T13: AsExpression<ST13>,
T14: AsExpression<ST14>,
T15: AsExpression<ST15>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)>>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
ST9: SqlType + TypedExpressionType,
ST10: SqlType + TypedExpressionType,
ST11: SqlType + TypedExpressionType,
ST12: SqlType + TypedExpressionType,
ST13: SqlType + TypedExpressionType,
ST14: SqlType + TypedExpressionType,
ST15: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
T9: AsExpression<ST9>,
T10: AsExpression<ST10>,
T11: AsExpression<ST11>,
T12: AsExpression<ST12>,
T13: AsExpression<ST13>,
T14: AsExpression<ST14>,
T15: AsExpression<ST15>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
ST9: SqlType + TypedExpressionType,
ST10: SqlType + TypedExpressionType,
ST11: SqlType + TypedExpressionType,
ST12: SqlType + TypedExpressionType,
ST13: SqlType + TypedExpressionType,
ST14: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
T9: AsExpression<ST9>,
T10: AsExpression<ST10>,
T11: AsExpression<ST11>,
T12: AsExpression<ST12>,
T13: AsExpression<ST13>,
T14: AsExpression<ST14>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)>>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
ST9: SqlType + TypedExpressionType,
ST10: SqlType + TypedExpressionType,
ST11: SqlType + TypedExpressionType,
ST12: SqlType + TypedExpressionType,
ST13: SqlType + TypedExpressionType,
ST14: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
T9: AsExpression<ST9>,
T10: AsExpression<ST10>,
T11: AsExpression<ST11>,
T12: AsExpression<ST12>,
T13: AsExpression<ST13>,
T14: AsExpression<ST14>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
ST9: SqlType + TypedExpressionType,
ST10: SqlType + TypedExpressionType,
ST11: SqlType + TypedExpressionType,
ST12: SqlType + TypedExpressionType,
ST13: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
T9: AsExpression<ST9>,
T10: AsExpression<ST10>,
T11: AsExpression<ST11>,
T12: AsExpression<ST12>,
T13: AsExpression<ST13>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)>>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
ST9: SqlType + TypedExpressionType,
ST10: SqlType + TypedExpressionType,
ST11: SqlType + TypedExpressionType,
ST12: SqlType + TypedExpressionType,
ST13: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
T9: AsExpression<ST9>,
T10: AsExpression<ST10>,
T11: AsExpression<ST11>,
T12: AsExpression<ST12>,
T13: AsExpression<ST13>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
ST9: SqlType + TypedExpressionType,
ST10: SqlType + TypedExpressionType,
ST11: SqlType + TypedExpressionType,
ST12: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
T9: AsExpression<ST9>,
T10: AsExpression<ST10>,
T11: AsExpression<ST11>,
T12: AsExpression<ST12>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)>>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
ST9: SqlType + TypedExpressionType,
ST10: SqlType + TypedExpressionType,
ST11: SqlType + TypedExpressionType,
ST12: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
T9: AsExpression<ST9>,
T10: AsExpression<ST10>,
T11: AsExpression<ST11>,
T12: AsExpression<ST12>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
ST9: SqlType + TypedExpressionType,
ST10: SqlType + TypedExpressionType,
ST11: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
T9: AsExpression<ST9>,
T10: AsExpression<ST10>,
T11: AsExpression<ST11>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)>>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
ST9: SqlType + TypedExpressionType,
ST10: SqlType + TypedExpressionType,
ST11: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
T9: AsExpression<ST9>,
T10: AsExpression<ST10>,
T11: AsExpression<ST11>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
ST9: SqlType + TypedExpressionType,
ST10: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
T9: AsExpression<ST9>,
T10: AsExpression<ST10>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)>>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
ST9: SqlType + TypedExpressionType,
ST10: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
T9: AsExpression<ST9>,
T10: AsExpression<ST10>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
ST9: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
T9: AsExpression<ST9>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
ST9: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
T9: AsExpression<ST9>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
ST8: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
T8: AsExpression<ST8>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>> for (T0, T1, T2, T3, T4, T5, T6, T7) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>> for (T0, T1, T2, T3, T4, T5, T6, T7) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
ST7: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
T7: AsExpression<ST7>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, T1, T2, T3, T4, T5, T6, ST0, ST1, ST2, ST3, ST4, ST5, ST6> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>> for (T0, T1, T2, T3, T4, T5, T6) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>>,
impl<T0, T1, T2, T3, T4, T5, T6, ST0, ST1, ST2, ST3, ST4, ST5, ST6> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>> for (T0, T1, T2, T3, T4, T5, T6) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
ST6: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
T6: AsExpression<ST6>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, T1, T2, T3, T4, T5, ST0, ST1, ST2, ST3, ST4, ST5> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5)>> for (T0, T1, T2, T3, T4, T5) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5)>>,
impl<T0, T1, T2, T3, T4, T5, ST0, ST1, ST2, ST3, ST4, ST5> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5)>> for (T0, T1, T2, T3, T4, T5) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
ST5: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
T5: AsExpression<ST5>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, T1, T2, T3, T4, ST0, ST1, ST2, ST3, ST4> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4)>> for (T0, T1, T2, T3, T4) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4)>>,
impl<T0, T1, T2, T3, T4, ST0, ST1, ST2, ST3, ST4> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4)>> for (T0, T1, T2, T3, T4) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
ST4: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
T4: AsExpression<ST4>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, T1, T2, T3, ST0, ST1, ST2, ST3> AsExpression<Record<(ST0, ST1, ST2, ST3)>> for (T0, T1, T2, T3) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3)>>,
impl<T0, T1, T2, T3, ST0, ST1, ST2, ST3> AsExpression<Record<(ST0, ST1, ST2, ST3)>> for (T0, T1, T2, T3) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
ST3: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
T3: AsExpression<ST3>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, T1, T2, ST0, ST1, ST2> AsExpression<Record<(ST0, ST1, ST2)>> for (T0, T1, T2) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2)>>,
impl<T0, T1, T2, ST0, ST1, ST2> AsExpression<Record<(ST0, ST1, ST2)>> for (T0, T1, T2) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
ST2: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
T2: AsExpression<ST2>,
PgTuple<(T0::Expression, T1::Expression, T2::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, T1, ST0, ST1> AsExpression<Record<(ST0, ST1)>> for (T0, T1) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
PgTuple<(T0::Expression, T1::Expression)>: Expression<SqlType = Record<(ST0, ST1)>>,
impl<T0, T1, ST0, ST1> AsExpression<Record<(ST0, ST1)>> for (T0, T1) where
ST0: SqlType + TypedExpressionType,
ST1: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
T1: AsExpression<ST1>,
PgTuple<(T0::Expression, T1::Expression)>: Expression<SqlType = Record<(ST0, ST1)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, ST0> AsExpression<Record<(ST0,)>> for (T0,) where
ST0: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
PgTuple<(T0::Expression,)>: Expression<SqlType = Record<(ST0,)>>,
impl<T0, ST0> AsExpression<Record<(ST0,)>> for (T0,) where
ST0: SqlType + TypedExpressionType,
T0: AsExpression<ST0>,
PgTuple<(T0::Expression,)>: Expression<SqlType = Record<(ST0,)>>,
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression,)>
type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression,)>
The expression being returned
sourcefn as_expression(self) -> Self::Expression
fn as_expression(self) -> Self::Expression
Perform the conversion
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
T9: FromSql<ST9, Pg>,
T10: FromSql<ST10, Pg>,
T11: FromSql<ST11, Pg>,
T12: FromSql<ST12, Pg>,
T13: FromSql<ST13, Pg>,
T14: FromSql<ST14, Pg>,
T15: FromSql<ST15, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
T9: FromSql<ST9, Pg>,
T10: FromSql<ST10, Pg>,
T11: FromSql<ST11, Pg>,
T12: FromSql<ST12, Pg>,
T13: FromSql<ST13, Pg>,
T14: FromSql<ST14, Pg>,
T15: FromSql<ST15, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
T9: FromSql<ST9, Pg>,
T10: FromSql<ST10, Pg>,
T11: FromSql<ST11, Pg>,
T12: FromSql<ST12, Pg>,
T13: FromSql<ST13, Pg>,
T14: FromSql<ST14, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
T9: FromSql<ST9, Pg>,
T10: FromSql<ST10, Pg>,
T11: FromSql<ST11, Pg>,
T12: FromSql<ST12, Pg>,
T13: FromSql<ST13, Pg>,
T14: FromSql<ST14, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
T9: FromSql<ST9, Pg>,
T10: FromSql<ST10, Pg>,
T11: FromSql<ST11, Pg>,
T12: FromSql<ST12, Pg>,
T13: FromSql<ST13, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
T9: FromSql<ST9, Pg>,
T10: FromSql<ST10, Pg>,
T11: FromSql<ST11, Pg>,
T12: FromSql<ST12, Pg>,
T13: FromSql<ST13, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
T9: FromSql<ST9, Pg>,
T10: FromSql<ST10, Pg>,
T11: FromSql<ST11, Pg>,
T12: FromSql<ST12, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
T9: FromSql<ST9, Pg>,
T10: FromSql<ST10, Pg>,
T11: FromSql<ST11, Pg>,
T12: FromSql<ST12, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
T9: FromSql<ST9, Pg>,
T10: FromSql<ST10, Pg>,
T11: FromSql<ST11, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
T9: FromSql<ST9, Pg>,
T10: FromSql<ST10, Pg>,
T11: FromSql<ST11, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
T9: FromSql<ST9, Pg>,
T10: FromSql<ST10, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
T9: FromSql<ST9, Pg>,
T10: FromSql<ST10, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
T9: FromSql<ST9, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
T9: FromSql<ST9, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
T8: FromSql<ST8, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
T7: FromSql<ST7, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, ST0, ST1, ST2, ST3, ST4, ST5, ST6> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>, Pg> for (T0, T1, T2, T3, T4, T5, T6) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, ST0, ST1, ST2, ST3, ST4, ST5, ST6> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>, Pg> for (T0, T1, T2, T3, T4, T5, T6) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
T6: FromSql<ST6, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, ST0, ST1, ST2, ST3, ST4, ST5> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5)>, Pg> for (T0, T1, T2, T3, T4, T5) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
impl<T0, T1, T2, T3, T4, T5, ST0, ST1, ST2, ST3, ST4, ST5> FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5)>, Pg> for (T0, T1, T2, T3, T4, T5) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
T5: FromSql<ST5, Pg>,
sourceimpl<T0, T1, T2, T3, T4, ST0, ST1, ST2, ST3, ST4> FromSql<Record<(ST0, ST1, ST2, ST3, ST4)>, Pg> for (T0, T1, T2, T3, T4) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
impl<T0, T1, T2, T3, T4, ST0, ST1, ST2, ST3, ST4> FromSql<Record<(ST0, ST1, ST2, ST3, ST4)>, Pg> for (T0, T1, T2, T3, T4) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
T4: FromSql<ST4, Pg>,
sourceimpl<T0, T1, T2, T3, ST0, ST1, ST2, ST3> FromSql<Record<(ST0, ST1, ST2, ST3)>, Pg> for (T0, T1, T2, T3) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
impl<T0, T1, T2, T3, ST0, ST1, ST2, ST3> FromSql<Record<(ST0, ST1, ST2, ST3)>, Pg> for (T0, T1, T2, T3) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
T3: FromSql<ST3, Pg>,
sourceimpl<T0, T1, T2, ST0, ST1, ST2> FromSql<Record<(ST0, ST1, ST2)>, Pg> for (T0, T1, T2) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
impl<T0, T1, T2, ST0, ST1, ST2> FromSql<Record<(ST0, ST1, ST2)>, Pg> for (T0, T1, T2) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
T2: FromSql<ST2, Pg>,
sourceimpl<T0, T1, ST0, ST1> FromSql<Record<(ST0, ST1)>, Pg> for (T0, T1) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
impl<T0, T1, ST0, ST1> FromSql<Record<(ST0, ST1)>, Pg> for (T0, T1) where
T0: FromSql<ST0, Pg>,
T1: FromSql<ST1, Pg>,
sourceimpl<ST: 'static> HasSqlType<Record<ST>> for Pg
impl<ST: 'static> HasSqlType<Record<ST>> for Pg
sourcefn metadata(_: &mut Self::MetadataLookup) -> PgTypeMetadata
fn metadata(_: &mut Self::MetadataLookup) -> PgTypeMetadata
Fetch the metadata for the given type Read more
sourceimpl<ST: 'static + QueryId> QueryId for Record<ST>
impl<ST: 'static + QueryId> QueryId for Record<ST>
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)>, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)>, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)>, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)>, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)>, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)>, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)>, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)>, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)>, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)>, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)>, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)>, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, T7, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, T6, ST0, ST1, ST2, ST3, ST4, ST5, ST6> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>, Pg> for (T0, T1, T2, T3, T4, T5, T6) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>, Pg>,
impl<T0, T1, T2, T3, T4, T5, T6, ST0, ST1, ST2, ST3, ST4, ST5, ST6> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>, Pg> for (T0, T1, T2, T3, T4, T5, T6) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>, Pg>,
sourceimpl<T0, T1, T2, T3, T4, T5, ST0, ST1, ST2, ST3, ST4, ST5> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5)>, Pg> for (T0, T1, T2, T3, T4, T5) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5)>, Pg>,
impl<T0, T1, T2, T3, T4, T5, ST0, ST1, ST2, ST3, ST4, ST5> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5)>, Pg> for (T0, T1, T2, T3, T4, T5) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5)>, Pg>,
sourceimpl<T0, T1, T2, T3, T4, ST0, ST1, ST2, ST3, ST4> Queryable<Record<(ST0, ST1, ST2, ST3, ST4)>, Pg> for (T0, T1, T2, T3, T4) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4)>, Pg>,
impl<T0, T1, T2, T3, T4, ST0, ST1, ST2, ST3, ST4> Queryable<Record<(ST0, ST1, ST2, ST3, ST4)>, Pg> for (T0, T1, T2, T3, T4) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4)>, Pg>,
sourceimpl<T0, T1, T2, T3, ST0, ST1, ST2, ST3> Queryable<Record<(ST0, ST1, ST2, ST3)>, Pg> for (T0, T1, T2, T3) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3)>, Pg>,
impl<T0, T1, T2, T3, ST0, ST1, ST2, ST3> Queryable<Record<(ST0, ST1, ST2, ST3)>, Pg> for (T0, T1, T2, T3) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3)>, Pg>,
sourceimpl<T0, T1, T2, ST0, ST1, ST2> Queryable<Record<(ST0, ST1, ST2)>, Pg> for (T0, T1, T2) where
Self: FromSql<Record<(ST0, ST1, ST2)>, Pg>,
impl<T0, T1, T2, ST0, ST1, ST2> Queryable<Record<(ST0, ST1, ST2)>, Pg> for (T0, T1, T2) where
Self: FromSql<Record<(ST0, ST1, ST2)>, Pg>,
sourceimpl<T0, T1, ST0, ST1> Queryable<Record<(ST0, ST1)>, Pg> for (T0, T1) where
Self: FromSql<Record<(ST0, ST1)>, Pg>,
impl<T0, T1, ST0, ST1> Queryable<Record<(ST0, ST1)>, Pg> for (T0, T1) where
Self: FromSql<Record<(ST0, ST1)>, Pg>,
sourceimpl<T0, ST0> Queryable<Record<(ST0,)>, Pg> for (T0,) where
Self: FromSql<Record<(ST0,)>, Pg>,
impl<T0, ST0> Queryable<Record<(ST0,)>, Pg> for (T0,) where
Self: FromSql<Record<(ST0,)>, Pg>,
impl<ST: Copy + 'static> Copy for Record<ST>
impl<ST: 'static> SingleValue for Record<ST>
Auto Trait Implementations
impl<ST> RefUnwindSafe for Record<ST> where
ST: RefUnwindSafe,
impl<ST> Send for Record<ST> where
ST: Send,
impl<ST> Sync for Record<ST> where
ST: Sync,
impl<ST> Unpin for Record<ST> where
ST: Unpin,
impl<ST> UnwindSafe for Record<ST> where
ST: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> IntoNotNullable for T where
T: SqlType<IsNull = NotNull>,
impl<T> IntoNotNullable for T where
T: SqlType<IsNull = NotNull>,
type NotNullable = T
type NotNullable = T
The not nullable representation of this type. Read more
sourceimpl<T> IntoNullable for T where
T: SqlType<IsNull = NotNull> + SingleValue,
impl<T> IntoNullable for T where
T: SqlType<IsNull = NotNull> + SingleValue,
sourceimpl<T> IntoSql for T
impl<T> IntoSql for T
sourcefn into_sql<T>(self) -> AsExprOf<Self, T> where
Self: AsExpression<T> + Sized,
T: SqlType + TypedExpressionType,
fn into_sql<T>(self) -> AsExprOf<Self, T> where
Self: AsExpression<T> + Sized,
T: SqlType + TypedExpressionType,
Convert self
to an expression for Diesel’s query builder. Read more
sourcefn as_sql<'a, T>(&'a self) -> AsExprOf<&'a Self, T> where
&'a Self: AsExpression<T>,
T: SqlType + TypedExpressionType,
fn as_sql<'a, T>(&'a self) -> AsExprOf<&'a Self, T> where
&'a Self: AsExpression<T>,
T: SqlType + TypedExpressionType,
Convert &self
to an expression for Diesel’s query builder. Read more