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.

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.

Deriving

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

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 effect.

To provide custom deserialization behavior for a field, you can use #[diesel(deserialize_as = "Type")]. If this attribute is present, Diesel will deserialize into that type, rather than the type on your struct and call .into to convert it. This can be used to add custom behavior for a single field, or use types that are otherwise unsupported by Diesel.

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 use deserialize_as to use a different implementation.

struct LowercaseString(String);

impl Into<String> for LowercaseString {
    fn into(self) -> String {
        self.0
    }
}

impl<DB, ST> Queryable<ST, DB> for LowercaseString
where
    DB: Backend,
    String: Queryable<ST, DB>,
{
    type Row = <String as Queryable<ST, DB>>::Row;

    fn build(row: Self::Row) -> Self {
        LowercaseString(String::build(row).to_lowercase())
    }
}

#[derive(Queryable, PartialEq, Debug)]
struct User {
    id: i32,
    #[diesel(deserialize_as = "LowercaseString")]
    name: String,
}

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

Alternatively, we can implement the trait for our struct manually.

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.

Loading content...

Required methods

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

Construct an instance of this type

Loading content...

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

Loading content...

Implementors

Loading content...