Trait diesel::deserialize::Queryable

pub trait Queryable<ST, DB>: Sized where
    DB: Backend, {
    type Row: FromStaticSqlRow<ST, DB>;
    fn build(row: Self::Row) -> Result<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.

This trait can be derived

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> Queryable<Text, DB> for LowercaseString
where
    DB: Backend,
    String: FromSql<Text, DB>,
{
    type Row = String;

    fn build(s: String) -> deserialize::Result<Self> {
        Ok(LowercaseString(s.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::{self, 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) -> deserialize::Result<Self> {
        Ok(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: FromStaticSqlRow<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) -> Result<Self>

Construct an instance of this type

Loading content...

Implementations on Foreign Types

impl<__ST, __DB> Queryable<__ST, __DB> for [u8; 6] where
    __DB: Backend,
    __ST: SingleValue,
    Self: FromSql<__ST, __DB>, 

type Row = Self

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

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

type Row = Self

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

impl<T, ST> Queryable<Range<ST>, Pg> for (Bound<T>, Bound<T>) where
    T: FromSql<ST, Pg>, 

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, Pg>, 

type Row = Self

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

type Row = Self

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

type Row = Self

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

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>, Pg> 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
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)>, Pg> 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
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(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)>, Pg> 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
    Self: FromSql<Record<(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)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(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)>, Pg> 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
    Self: FromSql<Record<(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)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(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)>, Pg> 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
    Self: FromSql<Record<(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)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(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)>, Pg> 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
    Self: FromSql<Record<(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)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(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)>, Pg> 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
    Self: FromSql<Record<(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)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(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)>, Pg> 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
    Self: FromSql<Record<(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)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(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)>, Pg> 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
    Self: FromSql<Record<(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)>, Pg>, 

type Row = Self

fn build(row: Self::Row) -> Result<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> Queryable<Record<(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)>, Pg> 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
    Self: FromSql<Record<(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)>, Pg>, 

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

impl<ST, T, DB> Queryable<ST, DB> for Option<T> where
    ST: SingleValue<IsNull = IsNullable>,
    DB: Backend,
    Self: FromSql<ST, DB>, 

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

impl<'a, T: ?Sized, ST, DB> Queryable<ST, DB> for Cow<'a, T> where
    T: 'a + ToOwned,
    ST: SingleValue,
    DB: Backend,
    Self: FromSql<ST, DB>, 

type Row = Self

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

impl<A, __DB, SA> Queryable<(SA,), __DB> for (A,) where
    __DB: Backend,
    Self: FromStaticSqlRow<(SA,), __DB>, 

type Row = Self

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

impl<__T, __DB, SA> Queryable<Nullable<(SA,)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA,)>, __DB>,
    (SA,): SqlType, 

type Row = Self

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

impl<A, B, __DB, SA, SB> Queryable<(SA, SB), __DB> for (A, B) where
    __DB: Backend,
    Self: FromStaticSqlRow<(SA, SB), __DB>, 

type Row = Self

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

impl<__T, __DB, SA, SB> Queryable<Nullable<(SA, SB)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB)>, __DB>,
    (SA, SB): SqlType, 

type Row = Self

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

impl<A, B, C, __DB, SA, SB, SC> Queryable<(SA, SB, SC), __DB> for (A, B, C) where
    __DB: Backend,
    Self: FromStaticSqlRow<(SA, SB, SC), __DB>, 

type Row = Self

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

impl<__T, __DB, SA, SB, SC> Queryable<Nullable<(SA, SB, SC)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC)>, __DB>,
    (SA, SB, SC): SqlType, 

type Row = Self

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

impl<A, B, C, D, __DB, SA, SB, SC, SD> Queryable<(SA, SB, SC, SD), __DB> for (A, B, C, D) where
    __DB: Backend,
    Self: FromStaticSqlRow<(SA, SB, SC, SD), __DB>, 

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD> Queryable<Nullable<(SA, SB, SC, SD)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD)>, __DB>,
    (SA, SB, SC, SD): SqlType, 

type Row = Self

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

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

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE> Queryable<Nullable<(SA, SB, SC, SD, SE)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE)>, __DB>,
    (SA, SB, SC, SD, SE): SqlType, 

type Row = Self

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

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

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF> Queryable<Nullable<(SA, SB, SC, SD, SE, SF)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF)>, __DB>,
    (SA, SB, SC, SD, SE, SF): SqlType, 

type Row = Self

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

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

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG): SqlType, 

type Row = Self

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

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

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH): SqlType, 

type Row = Self

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

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

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): SqlType, 

type Row = Self

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

impl<A, B, C, D, E, F, G, H, I, J, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> 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,
    Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ), __DB>, 

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): SqlType, 

type Row = Self

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

impl<A, B, C, D, E, F, G, H, I, J, K, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> 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,
    Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK), __DB>, 

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): SqlType, 

type Row = Self

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> 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,
    Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL), __DB>, 

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): SqlType, 

type Row = Self

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> 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,
    Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM), __DB>, 

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): SqlType, 

type Row = Self

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

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

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): SqlType, 

type Row = Self

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

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

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): SqlType, 

type Row = Self

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

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

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): SqlType, 

type Row = Self

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

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

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ): SqlType, 

type Row = Self

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR> 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,
    Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR), __DB>, 

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR): SqlType, 

type Row = Self

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS> 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,
    Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS), __DB>, 

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS): SqlType, 

type Row = Self

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST> 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,
    Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST), __DB>, 

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST): SqlType, 

type Row = Self

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU> 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,
    Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU), __DB>, 

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU): SqlType, 

type Row = Self

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV> 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,
    Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV), __DB>, 

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV> Queryable<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>, __DB> for Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV): SqlType, 

type Row = Self

fn build(row: Self::Row) -> Result<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, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW> 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,
    Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW), __DB>, 

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW> Queryable<Nullable<(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 Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>, __DB>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW): SqlType, 

type Row = Self

fn build(row: Self::Row) -> Result<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, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX> 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,
    Self: FromStaticSqlRow<(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>, 

type Row = Self

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

impl<__T, __DB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX> Queryable<Nullable<(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 Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(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>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX): SqlType, 

type Row = Self

fn build(row: Self::Row) -> Result<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, __DB, 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> 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,
    Self: FromStaticSqlRow<(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>, 

type Row = Self

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

impl<__T, __DB, 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> Queryable<Nullable<(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 Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(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>,
    (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): SqlType, 

type Row = Self

fn build(row: Self::Row) -> Result<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, __DB, 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> 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,
    Self: FromStaticSqlRow<(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>, 

type Row = Self

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

impl<__T, __DB, 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> Queryable<Nullable<(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 Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(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>,
    (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): SqlType, 

type Row = Self

fn build(row: Self::Row) -> Result<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, __DB, 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> 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,
    Self: FromStaticSqlRow<(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>, 

type Row = Self

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

impl<__T, __DB, 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> Queryable<Nullable<(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 Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(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>,
    (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): SqlType, 

type Row = Self

fn build(row: Self::Row) -> Result<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, __DB, 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> 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,
    Self: FromStaticSqlRow<(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>, 

type Row = Self

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

impl<__T, __DB, 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> Queryable<Nullable<(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 Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(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>,
    (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): SqlType, 

type Row = Self

fn build(row: Self::Row) -> Result<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, __DB, 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> 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,
    Self: FromStaticSqlRow<(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>, 

type Row = Self

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

impl<__T, __DB, 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> Queryable<Nullable<(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 Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(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>,
    (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): SqlType, 

type Row = Self

fn build(row: Self::Row) -> Result<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, __DB, 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> 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,
    Self: FromStaticSqlRow<(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>, 

type Row = Self

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

impl<__T, __DB, 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> Queryable<Nullable<(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 Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(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>,
    (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): SqlType, 

type Row = Self

fn build(row: Self::Row) -> Result<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, __DB, 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> 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,
    Self: FromStaticSqlRow<(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>, 

type Row = Self

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

impl<__T, __DB, 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> Queryable<Nullable<(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 Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(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>,
    (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): SqlType, 

type Row = Self

fn build(row: Self::Row) -> Result<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, __DB, 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> 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,
    Self: FromStaticSqlRow<(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>, 

type Row = Self

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

impl<__T, __DB, 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> Queryable<Nullable<(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 Option<__T> where
    __DB: Backend,
    Self: FromStaticSqlRow<Nullable<(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>,
    (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): SqlType, 

type Row = Self

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

Loading content...

Implementors

impl<'a, __ST, __DB> Queryable<__ST, __DB> for MigrationVersion<'a> where
    __DB: Backend,
    __ST: SingleValue,
    Self: FromSql<__ST, __DB>, 

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

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

type Row = Self

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

Loading content...