Trait block_tools::db::use_diesel::deserialize::QueryableByName

pub trait QueryableByName<DB> where
    DB: Backend, {
    pub fn build<R>(
        row: &R
    ) -> Result<Self, Box<dyn Error + 'static + Send + Sync, Global>>
    where
        R: NamedRow<DB>;
}

Deserializes the result of a query constructed with sql_query.

Deriving

To derive this trait, Diesel needs to know the SQL type of each field. You can do this by either annotating your struct with #[table_name = "some_table"] (in which case the SQL type will be diesel::dsl::SqlTypeOf<table_name::column_name>), or by annotating each field with #[sql_type = "SomeType"].

If you are using #[table_name], the module for that table must be in scope. For example, to derive this for a struct called User, you will likely need a line such as use schema::users;

If the name of a field on your struct is different than the column in your table! declaration, or if you are deriving this trait on a tuple struct, you can annotate the field with #[column_name = "some_column"]. For tuple structs, all fields must have this annotation.

If a field is another struct which implements QueryableByName, instead of a column, you can annotate that struct with #[diesel(embed)]

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(QueryableByName, PartialEq, Debug)]
#[table_name = "users"]
struct User {
    id: i32,
    name: String,
}

let first_user = sql_query("SELECT * FROM users ORDER BY id LIMIT 1")
    .get_result(&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> FromSql<ST, DB> for LowercaseString
where
    DB: Backend,
    String: FromSql<ST, DB>,
{
    fn from_sql(bytes: Option<&DB::RawValue>) -> deserialize::Result<Self> {
        String::from_sql(bytes)
            .map(|s| LowercaseString(s.to_lowercase()))
    }
}

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

let first_user = sql_query("SELECT * FROM users ORDER BY id LIMIT 1")
    .get_result(&connection)?;
let expected = User { id: 1, name: "sean".into() };
assert_eq!(expected, first_user);

Required methods

pub fn build<R>(
    row: &R
) -> Result<Self, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: NamedRow<DB>, 

Construct an instance of Self from the database row

Loading content...

Implementations on Foreign Types

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> QueryableByName<__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
    C: QueryableByName<__DB>,
    S: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    W: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    T: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    U: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    R: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    V: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>,
    X: QueryableByName<__DB>,
    Y: QueryableByName<__DB>,
    Z: QueryableByName<__DB>,
    AA: QueryableByName<__DB>,
    AB: QueryableByName<__DB>,
    AC: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(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), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, __DB> QueryableByName<__DB> for (A, B, C, D, E, F, G, H, I, J, K) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

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> QueryableByName<__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
    C: QueryableByName<__DB>,
    S: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    W: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    T: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    U: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    R: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    V: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>,
    X: QueryableByName<__DB>,
    Y: QueryableByName<__DB>,
    Z: QueryableByName<__DB>,
    AA: QueryableByName<__DB>,
    AB: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(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), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, __DB> QueryableByName<__DB> for (A, B, C, D, E, F, G, H, I, J) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, G, H, __DB> QueryableByName<__DB> for (A, B, C, D, E, F, G, H) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, __DB> QueryableByName<__DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    C: QueryableByName<__DB>,
    S: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    T: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    R: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, __DB> QueryableByName<__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
    C: QueryableByName<__DB>,
    S: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    T: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    U: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    R: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    V: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, __DB> QueryableByName<__DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    R: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, __DB> QueryableByName<__DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, __DB> QueryableByName<__DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<T, DB> QueryableByName<DB> for Option<T> where
    DB: Backend,
    T: QueryableByName<DB>, 

pub fn build<R>(
    row: &R
) -> Result<Option<T>, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: NamedRow<DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, __DB> QueryableByName<__DB> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, __DB> QueryableByName<__DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

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> QueryableByName<__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
    C: QueryableByName<__DB>,
    S: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    W: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    T: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    U: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    R: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    V: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>,
    X: QueryableByName<__DB>,
    Y: QueryableByName<__DB>,
    Z: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(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), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, __DB> QueryableByName<__DB> for (A, B, C, D, E) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    D: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    B: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, __DB> QueryableByName<__DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where
    C: QueryableByName<__DB>,
    S: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    R: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

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> QueryableByName<__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
    C: QueryableByName<__DB>,
    S: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    W: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    T: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    U: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    R: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    V: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>,
    X: QueryableByName<__DB>,
    Y: QueryableByName<__DB>,
    Z: QueryableByName<__DB>,
    AA: QueryableByName<__DB>,
    AB: QueryableByName<__DB>,
    AC: QueryableByName<__DB>,
    AD: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(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), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

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> QueryableByName<__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
    C: QueryableByName<__DB>,
    S: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    W: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    T: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    U: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    R: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    V: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>,
    X: QueryableByName<__DB>,
    Y: QueryableByName<__DB>,
    Z: QueryableByName<__DB>,
    AA: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(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), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

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> QueryableByName<__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
    C: QueryableByName<__DB>,
    S: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    W: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    T: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    U: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    R: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    V: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>,
    X: QueryableByName<__DB>,
    Y: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(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), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, __DB> QueryableByName<__DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, __DB> QueryableByName<__DB> for (A, B, C) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    A: QueryableByName<__DB>,
    B: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, __DB> QueryableByName<__DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where
    C: QueryableByName<__DB>,
    S: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    T: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    U: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    R: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, G, __DB> QueryableByName<__DB> for (A, B, C, D, E, F, G) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    B: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, __DB> QueryableByName<__DB> for (A, B, C, D) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    D: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    B: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, __DB> QueryableByName<__DB> for (A, B, C, D, E, F) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    B: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

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> QueryableByName<__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
    C: QueryableByName<__DB>,
    S: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    W: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    T: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    U: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    R: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    V: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>,
    X: QueryableByName<__DB>,
    Y: QueryableByName<__DB>,
    Z: QueryableByName<__DB>,
    AA: QueryableByName<__DB>,
    AB: QueryableByName<__DB>,
    AC: QueryableByName<__DB>,
    AD: QueryableByName<__DB>,
    AE: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(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), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

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> QueryableByName<__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
    C: QueryableByName<__DB>,
    S: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    W: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    T: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    U: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    R: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    V: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>,
    X: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, __DB> QueryableByName<__DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

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> QueryableByName<__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
    C: QueryableByName<__DB>,
    S: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    W: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    T: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    U: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    R: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    V: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>,
    X: QueryableByName<__DB>,
    Y: QueryableByName<__DB>,
    Z: QueryableByName<__DB>,
    AA: QueryableByName<__DB>,
    AB: QueryableByName<__DB>,
    AC: QueryableByName<__DB>,
    AD: QueryableByName<__DB>,
    AE: QueryableByName<__DB>,
    AF: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(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), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

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> QueryableByName<__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
    C: QueryableByName<__DB>,
    S: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    W: QueryableByName<__DB>,
    O: QueryableByName<__DB>,
    L: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    T: QueryableByName<__DB>,
    M: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    U: QueryableByName<__DB>,
    P: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    R: QueryableByName<__DB>,
    K: QueryableByName<__DB>,
    V: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    N: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>,
    J: QueryableByName<__DB>,
    Q: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, __DB> QueryableByName<__DB> for (A,) where
    __DB: Backend,
    A: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A,), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, __DB> QueryableByName<__DB> for (A, B) where
    __DB: Backend,
    A: QueryableByName<__DB>,
    B: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

impl<A, B, C, D, E, F, G, H, I, __DB> QueryableByName<__DB> for (A, B, C, D, E, F, G, H, I) where
    C: QueryableByName<__DB>,
    __DB: Backend,
    F: QueryableByName<__DB>,
    D: QueryableByName<__DB>,
    G: QueryableByName<__DB>,
    E: QueryableByName<__DB>,
    A: QueryableByName<__DB>,
    I: QueryableByName<__DB>,
    B: QueryableByName<__DB>,
    H: QueryableByName<__DB>, 

pub fn build<RowT>(
    row: &RowT
) -> Result<(A, B, C, D, E, F, G, H, I), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: NamedRow<__DB>, 

Loading content...

Implementors

Loading content...