Trait diesel::deserialize::Queryable

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

Trait indicating that a record can be queried from the database.

Types which implement Queryable represent the result of a SQL query. This does not necessarily mean they represent a single database table.

This trait can be derived automatically using #[derive(Queryable)]. This trait can only be derived for structs, not enums.

Diesel represents the return type of a query as a tuple. The purpose of this trait is to convert from a tuple of Rust values that have been deserialized into your struct.

When this trait is derived, it will assume that the order of fields on your struct match the order of the fields in the query. This means that field order is significant if you are using #[derive(Queryable)]. Field name has no affect.

Examples

If we just want to map a query to our struct, we can use derive.

#[derive(Queryable, PartialEq, Debug)]
struct User {
    id: i32,
    name: String,
}

let first_user = users.first(&connection)?;
let expected = User { id: 1, name: "Sean".into() };
assert_eq!(expected, first_user);

If we want to do additional work during deserialization, we can implement the trait ourselves.

use schema::users;
use diesel::deserialize::Queryable;

type DB = diesel::sqlite::Sqlite;

#[derive(PartialEq, Debug)]
struct User {
    id: i32,
    name: String,
}

impl Queryable<users::SqlType, DB> for User {
    type Row = (i32, String);

    fn build(row: Self::Row) -> Self {
        User {
            id: row.0,
            name: row.1.to_lowercase(),
        }
    }
}

let first_user = users.first(&connection)?;
let expected = User { id: 1, name: "sean".into() };
assert_eq!(expected, first_user);

Associated Types

type Row: FromSqlRow<ST, DB>

The Rust type you'd like to map from.

This is typically a tuple of all of your struct's fields.

Required Methods

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

Construct an instance of this type

Implementations on Foreign Types

impl<__ST, __DB> Queryable<__ST, __DB> for SystemTime where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<__ST, __DB> Queryable<__ST, __DB> for NaiveDate where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<__ST, __DB> Queryable<__ST, __DB> for NaiveTime where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<__ST, __DB> Queryable<__ST, __DB> for NaiveDateTime where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<Tz: TimeZone, __ST, __DB> Queryable<__ST, __DB> for DateTime<Tz> where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

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

type Row = Option<T::Row>

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

impl<__ST, __DB> Queryable<__ST, __DB> for bool where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<__ST, __DB> Queryable<__ST, __DB> for i8 where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<__ST, __DB> Queryable<__ST, __DB> for i16 where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<__ST, __DB> Queryable<__ST, __DB> for i32 where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<__ST, __DB> Queryable<__ST, __DB> for i64 where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<__ST, __DB> Queryable<__ST, __DB> for u16 where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<__ST, __DB> Queryable<__ST, __DB> for u32 where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<__ST, __DB> Queryable<__ST, __DB> for u64 where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<__ST, __DB> Queryable<__ST, __DB> for f32 where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<__ST, __DB> Queryable<__ST, __DB> for f64 where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<__ST, __DB> Queryable<__ST, __DB> for String where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<T, __ST, __DB> Queryable<__ST, __DB> for Vec<T> where     __DB: Backend,     Self: FromSql<__ST, __DB>,

type Row = Self

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

impl<'a, T: ?Sized, ST, DB> Queryable<ST, DB> for Cow<'a, T> where     T: 'a + ToOwned,     DB: Backend,     Self: FromSqlRow<ST, 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>,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Implementors