Struct diesel::sql_types::Record

pub struct Record<ST: 'static>(_);

Available on crate feature postgres_backend only.

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

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)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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,)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

impl<ST: Clone + 'static> Clone for Record<ST>

fn clone(&self) -> Record<ST>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<ST: Debug + 'static> Debug for Record<ST>

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

Formats the value using the given formatter.

impl<ST: Default + 'static> Default for Record<ST>

fn default() -> Record<ST>

Returns the “default value” for a type.

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>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

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>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

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>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

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>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

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>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

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>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

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>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

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>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

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>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

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>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

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>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

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>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

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>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

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>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

impl<T0, T1, ST0, ST1> FromSql<Record<(ST0, ST1)>, Pg> for (T0, T1)where
    T0: FromSql<ST0, Pg>,
    T1: FromSql<ST1, Pg>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

impl<T0, ST0> FromSql<Record<(ST0,)>, Pg> for (T0,)where
    T0: FromSql<ST0, Pg>,

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql(bytes: Option<RawValue<'_, DB>>) -> Result<Self>

A specialized variant of from_sql for handling null values.

impl<ST: 'static> HasSqlType<Record<ST>> for Pg

fn metadata(_: &mut Self::MetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl<ST: 'static + QueryId> QueryId for Record<ST>

type QueryId = Record<<ST as QueryId>::QueryId>

A type which uniquely represents Self in a SQL query.

const HAS_STATIC_QUERY_ID: bool = _

Can the SQL generated by Self be uniquely identified by its type?

fn query_id() -> Option<TypeId>

Returns the type id of Self::QueryId if Self::HAS_STATIC_QUERY_ID. Returns None otherwise.

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>,

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

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>,

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

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>,

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

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>,

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

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>,

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

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>,

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

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>,

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

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>,

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

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>,

type Row = (T0, T1, T2, T3, T4, T5, T6, T7)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

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>,

type Row = (T0, T1, T2, T3, T4, T5, T6)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

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>,

type Row = (T0, T1, T2, T3, T4, T5)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

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>,

type Row = (T0, T1, T2, T3, T4)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

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>,

type Row = (T0, T1, T2, T3)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

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>,

type Row = (T0, T1, T2)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

impl<T0, T1, ST0, ST1> Queryable<Record<(ST0, ST1)>, Pg> for (T0, T1)where
    Self: FromSql<Record<(ST0, ST1)>, Pg>,

type Row = (T0, T1)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

impl<T0, ST0> Queryable<Record<(ST0,)>, Pg> for (T0,)where
    Self: FromSql<Record<(ST0,)>, Pg>,

type Row = (T0,)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Result<Self>

Construct an instance of this type

impl<ST: 'static> SqlType for Record<ST>

type IsNull = NotNull

Is this type nullable?

impl<ST: Copy + 'static> Copy for Record<ST>

impl<ST: 'static> SingleValue for Record<ST>