Trait diesel::deserialize::Queryable[−][src]

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

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

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

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

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

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

Examples

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

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

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

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

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

type DB = diesel::sqlite::Sqlite;

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

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

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

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

Associated Types

The Rust type you'd like to map from.

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

Required Methods

Construct an instance of this type

Implementations on Foreign Types

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

impl<A, SA> Queryable<Record<(SA,)>, Pg> for (A,) where
    Self: FromSqlRow<Record<(SA,)>, Pg>, 
[src]

impl<A, B, SA, SB> Queryable<Record<(SA, SB)>, Pg> for (A, B) where
    Self: FromSqlRow<Record<(SA, SB)>, Pg>, 
[src]

impl<A, B, C, SA, SB, SC> Queryable<Record<(SA, SB, SC)>, Pg> for (A, B, C) where
    Self: FromSqlRow<Record<(SA, SB, SC)>, Pg>, 
[src]

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

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: FromSqlRow<Record<(SA, SB, SC, SD, SE)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>, Pg>, 
[src]

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: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>, Pg>, 
[src]

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: FromSqlRow<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>, 
[src]

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: FromSqlRow<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>, 
[src]

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: FromSqlRow<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>, 
[src]

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: FromSqlRow<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>, 
[src]

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: FromSqlRow<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>, 
[src]

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: FromSqlRow<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>, 
[src]

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: FromSqlRow<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>, 
[src]

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: FromSqlRow<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>, 
[src]

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: FromSqlRow<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>, 
[src]

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: FromSqlRow<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>, 
[src]

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

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

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

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

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

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, 
[src]

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, T: ?Sized, ST, DB> Queryable<ST, DB> for Cow<'a, T> where
    T: 'a + ToOwned,
    DB: Backend,
    Self: FromSqlRow<ST, DB>, 
[src]

impl<A, SA, __DB> Queryable<(SA,), __DB> for (A,) where
    __DB: Backend,
    A: Queryable<SA, __DB>, 
[src]

impl<A, B, SA, SB, __DB> Queryable<(SA, SB), __DB> for (A, B) where
    __DB: Backend,
    A: Queryable<SA, __DB>,
    B: Queryable<SB, __DB>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

Implementors