Trait diesel::query_source::Queryable

pub trait Queryable<ST, DB> where
    DB: Backend + HasSqlType<ST>, {
    type Row: FromSqlRow<ST, DB>;
    fn build(row: Self::Row) -> Self;
}

Trait indicating that a record can be queried from the database. This trait can be derived automatically using diesel_codegen. This trait can only be derived for structs, not enums.

Associated Types

type Row: FromSqlRow<ST, DB>

Required Methods

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

Implementations on Foreign Types

impl<T, ST, DB> Queryable<Nullable<ST>, DB> for Option<T> where
    T: Queryable<ST, DB>,
    DB: Backend + HasSqlType<ST>,
    Option<T::Row>: FromSqlRow<Nullable<ST>, DB>,
    ST: NotNull, 

type Row = Option<T::Row>

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

impl<DB> Queryable<Bool, DB> for bool where
    DB: Backend + HasSqlType<Bool>,
    bool: FromSqlRow<Bool, DB>, 

type Row = Self

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

impl<DB> Queryable<SmallInt, DB> for i16 where
    DB: Backend + HasSqlType<SmallInt>,
    i16: FromSqlRow<SmallInt, DB>, 

type Row = Self

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

impl<DB> Queryable<Integer, DB> for i32 where
    DB: Backend + HasSqlType<Integer>,
    i32: FromSqlRow<Integer, DB>, 

type Row = Self

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

impl<DB> Queryable<BigInt, DB> for i64 where
    DB: Backend + HasSqlType<BigInt>,
    i64: FromSqlRow<BigInt, DB>, 

type Row = Self

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

impl<DB> Queryable<Float, DB> for f32 where
    DB: Backend + HasSqlType<Float>,
    f32: FromSqlRow<Float, DB>, 

type Row = Self

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

impl<DB> Queryable<Double, DB> for f64 where
    DB: Backend + HasSqlType<Double>,
    f64: FromSqlRow<Double, DB>, 

type Row = Self

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

impl<DB> Queryable<Text, DB> for String where
    DB: Backend + HasSqlType<Text>,
    String: FromSqlRow<Text, DB>, 

type Row = Self

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

impl<DB> Queryable<Binary, DB> for Vec<u8> where
    DB: Backend + HasSqlType<Binary>,
    Vec<u8>: FromSqlRow<Binary, DB>, 

type Row = Self

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

impl<A, SA, DB> Queryable<(SA,), DB> for (A,) where
    DB: Backend,
    A: Queryable<SA, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<(SA,)>, 

type Row = (A::Row,)

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

impl<A, B, SA, SB, DB> Queryable<(SA, SB), DB> for (A, B) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<(SA, SB)>, 

type Row = (A::Row, B::Row)

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

impl<A, B, C, SA, SB, SC, DB> Queryable<(SA, SB, SC), DB> for (A, B, C) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<(SA, SB, SC)>, 

type Row = (A::Row, B::Row, C::Row)

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

impl<A, B, C, D, SA, SB, SC, SD, DB> Queryable<(SA, SB, SC, SD), DB> for (A, B, C, D) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<(SA, SB, SC, SD)>, 

type Row = (A::Row, B::Row, C::Row, D::Row)

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

impl<A, B, C, D, E, SA, SB, SC, SD, SE, DB> Queryable<(SA, SB, SC, SD, SE), DB> for (A, B, C, D, E) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<(SA, SB, SC, SD, SE)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row)

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

impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF, DB> Queryable<(SA, SB, SC, SD, SE, SF), DB> for (A, B, C, D, E, F) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row)

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

impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG), DB> for (A, B, C, D, E, F, G) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row)

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

impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH), DB> for (A, B, C, D, E, F, G, H) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row)

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

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, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL), DB> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row)

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

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, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row)

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

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, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, 

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

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

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

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

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

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

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

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row)

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

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

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    AL: Queryable<SAL, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<SAL>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row, AL::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    AL: Queryable<SAL, DB>,
    AM: Queryable<SAM, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<SAL>,
    DB: HasSqlType<SAM>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row, AL::Row, AM::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    AL: Queryable<SAL, DB>,
    AM: Queryable<SAM, DB>,
    AN: Queryable<SAN, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<SAL>,
    DB: HasSqlType<SAM>,
    DB: HasSqlType<SAN>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row, AL::Row, AM::Row, AN::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    AL: Queryable<SAL, DB>,
    AM: Queryable<SAM, DB>,
    AN: Queryable<SAN, DB>,
    AO: Queryable<SAO, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<SAL>,
    DB: HasSqlType<SAM>,
    DB: HasSqlType<SAN>,
    DB: HasSqlType<SAO>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row, AL::Row, AM::Row, AN::Row, AO::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    AL: Queryable<SAL, DB>,
    AM: Queryable<SAM, DB>,
    AN: Queryable<SAN, DB>,
    AO: Queryable<SAO, DB>,
    AP: Queryable<SAP, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<SAL>,
    DB: HasSqlType<SAM>,
    DB: HasSqlType<SAN>,
    DB: HasSqlType<SAO>,
    DB: HasSqlType<SAP>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row, AL::Row, AM::Row, AN::Row, AO::Row, AP::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    AL: Queryable<SAL, DB>,
    AM: Queryable<SAM, DB>,
    AN: Queryable<SAN, DB>,
    AO: Queryable<SAO, DB>,
    AP: Queryable<SAP, DB>,
    AQ: Queryable<SAQ, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<SAL>,
    DB: HasSqlType<SAM>,
    DB: HasSqlType<SAN>,
    DB: HasSqlType<SAO>,
    DB: HasSqlType<SAP>,
    DB: HasSqlType<SAQ>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row, AL::Row, AM::Row, AN::Row, AO::Row, AP::Row, AQ::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    AL: Queryable<SAL, DB>,
    AM: Queryable<SAM, DB>,
    AN: Queryable<SAN, DB>,
    AO: Queryable<SAO, DB>,
    AP: Queryable<SAP, DB>,
    AQ: Queryable<SAQ, DB>,
    AR: Queryable<SAR, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<SAL>,
    DB: HasSqlType<SAM>,
    DB: HasSqlType<SAN>,
    DB: HasSqlType<SAO>,
    DB: HasSqlType<SAP>,
    DB: HasSqlType<SAQ>,
    DB: HasSqlType<SAR>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row, AL::Row, AM::Row, AN::Row, AO::Row, AP::Row, AQ::Row, AR::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    AL: Queryable<SAL, DB>,
    AM: Queryable<SAM, DB>,
    AN: Queryable<SAN, DB>,
    AO: Queryable<SAO, DB>,
    AP: Queryable<SAP, DB>,
    AQ: Queryable<SAQ, DB>,
    AR: Queryable<SAR, DB>,
    AS: Queryable<SAS, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<SAL>,
    DB: HasSqlType<SAM>,
    DB: HasSqlType<SAN>,
    DB: HasSqlType<SAO>,
    DB: HasSqlType<SAP>,
    DB: HasSqlType<SAQ>,
    DB: HasSqlType<SAR>,
    DB: HasSqlType<SAS>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row, AL::Row, AM::Row, AN::Row, AO::Row, AP::Row, AQ::Row, AR::Row, AS::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    AL: Queryable<SAL, DB>,
    AM: Queryable<SAM, DB>,
    AN: Queryable<SAN, DB>,
    AO: Queryable<SAO, DB>,
    AP: Queryable<SAP, DB>,
    AQ: Queryable<SAQ, DB>,
    AR: Queryable<SAR, DB>,
    AS: Queryable<SAS, DB>,
    AT: Queryable<SAT, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<SAL>,
    DB: HasSqlType<SAM>,
    DB: HasSqlType<SAN>,
    DB: HasSqlType<SAO>,
    DB: HasSqlType<SAP>,
    DB: HasSqlType<SAQ>,
    DB: HasSqlType<SAR>,
    DB: HasSqlType<SAS>,
    DB: HasSqlType<SAT>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row, AL::Row, AM::Row, AN::Row, AO::Row, AP::Row, AQ::Row, AR::Row, AS::Row, AT::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    AL: Queryable<SAL, DB>,
    AM: Queryable<SAM, DB>,
    AN: Queryable<SAN, DB>,
    AO: Queryable<SAO, DB>,
    AP: Queryable<SAP, DB>,
    AQ: Queryable<SAQ, DB>,
    AR: Queryable<SAR, DB>,
    AS: Queryable<SAS, DB>,
    AT: Queryable<SAT, DB>,
    AU: Queryable<SAU, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<SAL>,
    DB: HasSqlType<SAM>,
    DB: HasSqlType<SAN>,
    DB: HasSqlType<SAO>,
    DB: HasSqlType<SAP>,
    DB: HasSqlType<SAQ>,
    DB: HasSqlType<SAR>,
    DB: HasSqlType<SAS>,
    DB: HasSqlType<SAT>,
    DB: HasSqlType<SAU>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row, AL::Row, AM::Row, AN::Row, AO::Row, AP::Row, AQ::Row, AR::Row, AS::Row, AT::Row, AU::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    AL: Queryable<SAL, DB>,
    AM: Queryable<SAM, DB>,
    AN: Queryable<SAN, DB>,
    AO: Queryable<SAO, DB>,
    AP: Queryable<SAP, DB>,
    AQ: Queryable<SAQ, DB>,
    AR: Queryable<SAR, DB>,
    AS: Queryable<SAS, DB>,
    AT: Queryable<SAT, DB>,
    AU: Queryable<SAU, DB>,
    AV: Queryable<SAV, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<SAL>,
    DB: HasSqlType<SAM>,
    DB: HasSqlType<SAN>,
    DB: HasSqlType<SAO>,
    DB: HasSqlType<SAP>,
    DB: HasSqlType<SAQ>,
    DB: HasSqlType<SAR>,
    DB: HasSqlType<SAS>,
    DB: HasSqlType<SAT>,
    DB: HasSqlType<SAU>,
    DB: HasSqlType<SAV>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row, AL::Row, AM::Row, AN::Row, AO::Row, AP::Row, AQ::Row, AR::Row, AS::Row, AT::Row, AU::Row, AV::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    AL: Queryable<SAL, DB>,
    AM: Queryable<SAM, DB>,
    AN: Queryable<SAN, DB>,
    AO: Queryable<SAO, DB>,
    AP: Queryable<SAP, DB>,
    AQ: Queryable<SAQ, DB>,
    AR: Queryable<SAR, DB>,
    AS: Queryable<SAS, DB>,
    AT: Queryable<SAT, DB>,
    AU: Queryable<SAU, DB>,
    AV: Queryable<SAV, DB>,
    AW: Queryable<SAW, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<SAL>,
    DB: HasSqlType<SAM>,
    DB: HasSqlType<SAN>,
    DB: HasSqlType<SAO>,
    DB: HasSqlType<SAP>,
    DB: HasSqlType<SAQ>,
    DB: HasSqlType<SAR>,
    DB: HasSqlType<SAS>,
    DB: HasSqlType<SAT>,
    DB: HasSqlType<SAU>,
    DB: HasSqlType<SAV>,
    DB: HasSqlType<SAW>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row, AL::Row, AM::Row, AN::Row, AO::Row, AP::Row, AQ::Row, AR::Row, AS::Row, AT::Row, AU::Row, AV::Row, AW::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    AL: Queryable<SAL, DB>,
    AM: Queryable<SAM, DB>,
    AN: Queryable<SAN, DB>,
    AO: Queryable<SAO, DB>,
    AP: Queryable<SAP, DB>,
    AQ: Queryable<SAQ, DB>,
    AR: Queryable<SAR, DB>,
    AS: Queryable<SAS, DB>,
    AT: Queryable<SAT, DB>,
    AU: Queryable<SAU, DB>,
    AV: Queryable<SAV, DB>,
    AW: Queryable<SAW, DB>,
    AX: Queryable<SAX, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<SAL>,
    DB: HasSqlType<SAM>,
    DB: HasSqlType<SAN>,
    DB: HasSqlType<SAO>,
    DB: HasSqlType<SAP>,
    DB: HasSqlType<SAQ>,
    DB: HasSqlType<SAR>,
    DB: HasSqlType<SAS>,
    DB: HasSqlType<SAT>,
    DB: HasSqlType<SAU>,
    DB: HasSqlType<SAV>,
    DB: HasSqlType<SAW>,
    DB: HasSqlType<SAX>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row, AL::Row, AM::Row, AN::Row, AO::Row, AP::Row, AQ::Row, AR::Row, AS::Row, AT::Row, AU::Row, AV::Row, AW::Row, AX::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    AL: Queryable<SAL, DB>,
    AM: Queryable<SAM, DB>,
    AN: Queryable<SAN, DB>,
    AO: Queryable<SAO, DB>,
    AP: Queryable<SAP, DB>,
    AQ: Queryable<SAQ, DB>,
    AR: Queryable<SAR, DB>,
    AS: Queryable<SAS, DB>,
    AT: Queryable<SAT, DB>,
    AU: Queryable<SAU, DB>,
    AV: Queryable<SAV, DB>,
    AW: Queryable<SAW, DB>,
    AX: Queryable<SAX, DB>,
    AY: Queryable<SAY, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<SAL>,
    DB: HasSqlType<SAM>,
    DB: HasSqlType<SAN>,
    DB: HasSqlType<SAO>,
    DB: HasSqlType<SAP>,
    DB: HasSqlType<SAQ>,
    DB: HasSqlType<SAR>,
    DB: HasSqlType<SAS>,
    DB: HasSqlType<SAT>,
    DB: HasSqlType<SAU>,
    DB: HasSqlType<SAV>,
    DB: HasSqlType<SAW>,
    DB: HasSqlType<SAX>,
    DB: HasSqlType<SAY>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row, AL::Row, AM::Row, AN::Row, AO::Row, AP::Row, AQ::Row, AR::Row, AS::Row, AT::Row, AU::Row, AV::Row, AW::Row, AX::Row, AY::Row)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, DB> Queryable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ) where
    DB: Backend,
    A: Queryable<SA, DB>,
    B: Queryable<SB, DB>,
    C: Queryable<SC, DB>,
    D: Queryable<SD, DB>,
    E: Queryable<SE, DB>,
    F: Queryable<SF, DB>,
    G: Queryable<SG, DB>,
    H: Queryable<SH, DB>,
    I: Queryable<SI, DB>,
    J: Queryable<SJ, DB>,
    K: Queryable<SK, DB>,
    L: Queryable<SL, DB>,
    M: Queryable<SM, DB>,
    N: Queryable<SN, DB>,
    O: Queryable<SO, DB>,
    P: Queryable<SP, DB>,
    Q: Queryable<SQ, DB>,
    R: Queryable<SR, DB>,
    S: Queryable<SS, DB>,
    T: Queryable<ST, DB>,
    U: Queryable<SU, DB>,
    V: Queryable<SV, DB>,
    W: Queryable<SW, DB>,
    X: Queryable<SX, DB>,
    Y: Queryable<SY, DB>,
    Z: Queryable<SZ, DB>,
    AA: Queryable<SAA, DB>,
    AB: Queryable<SAB, DB>,
    AC: Queryable<SAC, DB>,
    AD: Queryable<SAD, DB>,
    AE: Queryable<SAE, DB>,
    AF: Queryable<SAF, DB>,
    AG: Queryable<SAG, DB>,
    AH: Queryable<SAH, DB>,
    AI: Queryable<SAI, DB>,
    AJ: Queryable<SAJ, DB>,
    AK: Queryable<SAK, DB>,
    AL: Queryable<SAL, DB>,
    AM: Queryable<SAM, DB>,
    AN: Queryable<SAN, DB>,
    AO: Queryable<SAO, DB>,
    AP: Queryable<SAP, DB>,
    AQ: Queryable<SAQ, DB>,
    AR: Queryable<SAR, DB>,
    AS: Queryable<SAS, DB>,
    AT: Queryable<SAT, DB>,
    AU: Queryable<SAU, DB>,
    AV: Queryable<SAV, DB>,
    AW: Queryable<SAW, DB>,
    AX: Queryable<SAX, DB>,
    AY: Queryable<SAY, DB>,
    AZ: Queryable<SAZ, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<SQ>,
    DB: HasSqlType<SR>,
    DB: HasSqlType<SS>,
    DB: HasSqlType<ST>,
    DB: HasSqlType<SU>,
    DB: HasSqlType<SV>,
    DB: HasSqlType<SW>,
    DB: HasSqlType<SX>,
    DB: HasSqlType<SY>,
    DB: HasSqlType<SZ>,
    DB: HasSqlType<SAA>,
    DB: HasSqlType<SAB>,
    DB: HasSqlType<SAC>,
    DB: HasSqlType<SAD>,
    DB: HasSqlType<SAE>,
    DB: HasSqlType<SAF>,
    DB: HasSqlType<SAG>,
    DB: HasSqlType<SAH>,
    DB: HasSqlType<SAI>,
    DB: HasSqlType<SAJ>,
    DB: HasSqlType<SAK>,
    DB: HasSqlType<SAL>,
    DB: HasSqlType<SAM>,
    DB: HasSqlType<SAN>,
    DB: HasSqlType<SAO>,
    DB: HasSqlType<SAP>,
    DB: HasSqlType<SAQ>,
    DB: HasSqlType<SAR>,
    DB: HasSqlType<SAS>,
    DB: HasSqlType<SAT>,
    DB: HasSqlType<SAU>,
    DB: HasSqlType<SAV>,
    DB: HasSqlType<SAW>,
    DB: HasSqlType<SAX>,
    DB: HasSqlType<SAY>,
    DB: HasSqlType<SAZ>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ)>, 

type Row = (A::Row, B::Row, C::Row, D::Row, E::Row, F::Row, G::Row, H::Row, I::Row, J::Row, K::Row, L::Row, M::Row, N::Row, O::Row, P::Row, Q::Row, R::Row, S::Row, T::Row, U::Row, V::Row, W::Row, X::Row, Y::Row, Z::Row, AA::Row, AB::Row, AC::Row, AD::Row, AE::Row, AF::Row, AG::Row, AH::Row, AI::Row, AJ::Row, AK::Row, AL::Row, AM::Row, AN::Row, AO::Row, AP::Row, AQ::Row, AR::Row, AS::Row, AT::Row, AU::Row, AV::Row, AW::Row, AX::Row, AY::Row, AZ::Row)

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

impl<T, ST> Queryable<Array<ST>, Pg> for Vec<T> where
    T: FromSql<ST, Pg> + Queryable<ST, Pg>,
    Pg: HasSqlType<ST>, 

type Row = Self

fn build(row: Self) -> Self

impl<DB> Queryable<Timestamp, DB> for SystemTime where
    DB: Backend + HasSqlType<Timestamp>,
    SystemTime: FromSqlRow<Timestamp, DB>, 

type Row = Self

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

impl<DB> Queryable<Date, DB> for NaiveDate where
    DB: Backend + HasSqlType<Date>,
    NaiveDate: FromSqlRow<Date, DB>, 

type Row = Self

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

impl<DB> Queryable<Time, DB> for NaiveTime where
    DB: Backend + HasSqlType<Time>,
    NaiveTime: FromSqlRow<Time, DB>, 

type Row = Self

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

impl<DB> Queryable<Timestamp, DB> for NaiveDateTime where
    DB: Backend + HasSqlType<Timestamp>,
    NaiveDateTime: FromSqlRow<Timestamp, DB>, 

type Row = Self

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

impl<DB> Queryable<Timestamptz, DB> for DateTime<UTC> where
    DB: Backend + HasSqlType<Timestamptz>,
    DateTime<UTC>: FromSqlRow<Timestamptz, DB>, 

type Row = Self

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

impl<DB> Queryable<Oid, DB> for u32 where
    DB: Backend + HasSqlType<Oid>,
    u32: FromSqlRow<Oid, DB>, 

type Row = Self

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

impl<DB> Queryable<Uuid, DB> for Uuid where
    DB: Backend + HasSqlType<Uuid>,
    Uuid: FromSqlRow<Uuid, DB>, 

type Row = Self

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

impl<DB> Queryable<Date, DB> for String where
    DB: Backend + HasSqlType<Date>,
    String: FromSqlRow<Date, DB>, 

type Row = Self

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

impl<DB> Queryable<Time, DB> for String where
    DB: Backend + HasSqlType<Time>,
    String: FromSqlRow<Time, DB>, 

type Row = Self

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

impl<DB> Queryable<Timestamp, DB> for String where
    DB: Backend + HasSqlType<Timestamp>,
    String: FromSqlRow<Timestamp, DB>, 

type Row = Self

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

Implementors

• impl<DB> Queryable<Date, DB> for PgDate where
    DB: Backend + HasSqlType<Date>,
    PgDate: FromSqlRow<Date, DB>,  type Row = Self;
• impl<DB> Queryable<Time, DB> for PgTime where
    DB: Backend + HasSqlType<Time>,
    PgTime: FromSqlRow<Time, DB>,  type Row = Self;
• impl<DB> Queryable<Timestamp, DB> for PgTimestamp where
    DB: Backend + HasSqlType<Timestamp>,
    PgTimestamp: FromSqlRow<Timestamp, DB>,  type Row = Self;
• impl<DB> Queryable<Timestamptz, DB> for PgTimestamp where
    DB: Backend + HasSqlType<Timestamptz>,
    PgTimestamp: FromSqlRow<Timestamptz, DB>,  type Row = Self;
• impl<DB> Queryable<Interval, DB> for PgInterval where
    DB: Backend + HasSqlType<Interval>,
    PgInterval: FromSqlRow<Interval, DB>,  type Row = Self;
• impl<DB> Queryable<Numeric, DB> for PgNumeric where
    DB: Backend + HasSqlType<Numeric>,
    PgNumeric: FromSqlRow<Numeric, DB>,  type Row = Self;