Struct diesel::pg::types::sql_types::Record

pub struct Record<ST>(_);

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<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    A: AsExpression<SA>,
    B: AsExpression<SB>,
    C: AsExpression<SC>,
    D: AsExpression<SD>,
    E: AsExpression<SE>,
    F: AsExpression<SF>,
    G: AsExpression<SG>,
    H: AsExpression<SH>,
    I: AsExpression<SI>,
    J: AsExpression<SJ>,
    K: AsExpression<SK>,
    L: AsExpression<SL>,
    M: AsExpression<SM>,
    N: AsExpression<SN>,
    O: AsExpression<SO>,
    P: AsExpression<SP>,
    PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>>, 

type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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

type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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

type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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

type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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

type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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

type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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

type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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

type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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

type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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

type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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

type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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

type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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

type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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

type Expression = PgTuple<(A::Expression, B::Expression, C::Expression)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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

type Expression = PgTuple<(A::Expression, B::Expression)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

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

type Expression = PgTuple<(A::Expression,)>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

impl<ST: Clone> 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: Copy> Copy for Record<ST>

impl<ST: Debug> Debug for Record<ST>

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

Formats the value using the given formatter.

impl<ST: Default> Default for Record<ST>

fn default() -> Record<ST>

Returns the "default value" for a type.

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF> FromSql<Record<(SA, SB, SC, SD, SE, SF)>, Pg> for (A, B, C, D, E, F) where
    A: FromSql<SA, Pg>,
    B: FromSql<SB, Pg>,
    C: FromSql<SC, Pg>,
    D: FromSql<SD, Pg>,
    E: FromSql<SE, Pg>,
    F: FromSql<SF, Pg>, 

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl<A, B, C, D, E, SA, SB, SC, SD, SE> FromSql<Record<(SA, SB, SC, SD, SE)>, Pg> for (A, B, C, D, E) where
    A: FromSql<SA, Pg>,
    B: FromSql<SB, Pg>,
    C: FromSql<SC, Pg>,
    D: FromSql<SD, Pg>,
    E: FromSql<SE, Pg>, 

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl<A, B, C, D, SA, SB, SC, SD> FromSql<Record<(SA, SB, SC, SD)>, Pg> for (A, B, C, D) where
    A: FromSql<SA, Pg>,
    B: FromSql<SB, Pg>,
    C: FromSql<SC, Pg>,
    D: FromSql<SD, Pg>, 

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl<A, B, C, SA, SB, SC> FromSql<Record<(SA, SB, SC)>, Pg> for (A, B, C) where
    A: FromSql<SA, Pg>,
    B: FromSql<SB, Pg>,
    C: FromSql<SC, Pg>, 

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl<A, B, SA, SB> FromSql<Record<(SA, SB)>, Pg> for (A, B) where
    A: FromSql<SA, Pg>,
    B: FromSql<SB, Pg>, 

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl<A, SA> FromSql<Record<(SA,)>, Pg> for (A,) where
    A: FromSql<SA, Pg>, 

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

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

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

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

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

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

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

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

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

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

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

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

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg> for (A, B, C, D, E, F, G, H, I) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg>, 

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg> for (A, B, C, D, E, F, G, H) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg>, 

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg> for (A, B, C, D, E, F, G) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg>, 

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF)>, Pg> for (A, B, C, D, E, F) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF)>, Pg>, 

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

impl<A, B, C, D, E, SA, SB, SC, SD, SE> FromSqlRow<Record<(SA, SB, SC, SD, SE)>, Pg> for (A, B, C, D, E) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE)>, Pg>, 

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

impl<A, B, C, D, SA, SB, SC, SD> FromSqlRow<Record<(SA, SB, SC, SD)>, Pg> for (A, B, C, D) where
    Self: FromSql<Record<(SA, SB, SC, SD)>, Pg>, 

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

impl<A, B, C, SA, SB, SC> FromSqlRow<Record<(SA, SB, SC)>, Pg> for (A, B, C) where
    Self: FromSql<Record<(SA, SB, SC)>, Pg>, 

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

impl<A, B, SA, SB> FromSqlRow<Record<(SA, SB)>, Pg> for (A, B) where
    Self: FromSql<Record<(SA, SB)>, Pg>, 

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

impl<A, SA> FromSqlRow<Record<(SA,)>, Pg> for (A,) where
    Self: FromSql<Record<(SA,)>, Pg>, 

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

See the trait documentation.

impl<ST> HasSqlType<Record<ST>> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl<ST> NotNull for Record<ST>

impl<ST: 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<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, Pg>, 

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

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

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

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

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

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

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

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

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

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

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

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

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg> for (A, B, C, D, E, F, G, H, I) where
    Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg>, 

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg> for (A, B, C, D, E, F, G, H) where
    Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg>, 

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg> for (A, B, C, D, E, F, G) where
    Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg>, 

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF> Queryable<Record<(SA, SB, SC, SD, SE, SF)>, Pg> for (A, B, C, D, E, F) where
    Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF)>, Pg>, 

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

impl<A, B, C, D, E, SA, SB, SC, SD, SE> Queryable<Record<(SA, SB, SC, SD, SE)>, Pg> for (A, B, C, D, E) where
    Self: FromSqlRow<Record<(SA, SB, SC, SD, SE)>, Pg>, 

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

impl<A, B, C, D, SA, SB, SC, SD> Queryable<Record<(SA, SB, SC, SD)>, Pg> for (A, B, C, D) where
    Self: FromSqlRow<Record<(SA, SB, SC, SD)>, Pg>, 

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

impl<A, B, C, SA, SB, SC> Queryable<Record<(SA, SB, SC)>, Pg> for (A, B, C) where
    Self: FromSqlRow<Record<(SA, SB, SC)>, Pg>, 

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

impl<A, B, SA, SB> Queryable<Record<(SA, SB)>, Pg> for (A, B) where
    Self: FromSqlRow<Record<(SA, SB)>, Pg>, 

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

impl<A, SA> Queryable<Record<(SA,)>, Pg> for (A,) where
    Self: FromSqlRow<Record<(SA,)>, Pg>, 

type Row = Self

The Rust type you'd like to map from.

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

Construct an instance of this type

impl<ST> SingleValue for Record<ST>