[−][src]Trait diesel::deserialize::Queryable
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) -> Self { 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::Queryable; type DB = diesel::sqlite::Sqlite; #[derive(PartialEq, Debug)] struct User { id: i32, name: String, } impl Queryable<users::SqlType, DB> for User { type Row = (i32, String); fn build(row: Self::Row) -> Self { User { id: row.0, name: row.1.to_lowercase(), } } } let first_user = users.first(&connection)?; let expected = User { id: 1, name: "sean".into() }; assert_eq!(expected, first_user);
Associated Types
type Row: FromStaticSqlRow<ST, DB>
The Rust type you'd like to map from.
This is typically a tuple of all of your struct's fields.
Required methods
Loading content...Implementations on Foreign Types
impl<__ST, __DB> Queryable<__ST, __DB> for [u8; 6] where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for IpNetwork where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<T, ST> Queryable<Range<ST>, Pg> for (Bound<T>, Bound<T>) where
T: FromSql<ST, Pg>,
[src]
T: FromSql<ST, Pg>,
impl<A, SA> Queryable<Record<(SA,)>, Pg> for (A,) where
Self: FromSql<Record<(SA,)>, Pg>,
[src]
Self: FromSql<Record<(SA,)>, Pg>,
impl<A, B, SA, SB> Queryable<Record<(SA, SB)>, Pg> for (A, B) where
Self: FromSql<Record<(SA, SB)>, Pg>,
[src]
Self: FromSql<Record<(SA, SB)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE, SF)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>, Pg>,
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>,
[src]
Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>, Pg>,
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>,
[src]
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>,
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>,
[src]
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>,
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>,
[src]
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>,
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>,
[src]
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>,
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>,
[src]
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>,
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>,
[src]
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>,
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>,
[src]
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>,
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>,
[src]
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>,
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>,
[src]
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>,
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>,
[src]
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>,
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>,
[src]
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>,
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>,
[src]
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>,
impl<__ST, __DB> Queryable<__ST, __DB> for Uuid where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for SystemTime where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for NaiveDate where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for NaiveTime where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for NaiveDateTime where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<Tz: TimeZone, __ST, __DB> Queryable<__ST, __DB> for DateTime<Tz> where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for BigDecimal where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for Value where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<ST, T, DB> Queryable<ST, DB> for Option<T> where
ST: SingleValue<IsNull = IsNullable>,
DB: Backend,
Self: FromSql<ST, DB>,
[src]
ST: SingleValue<IsNull = IsNullable>,
DB: Backend,
Self: FromSql<ST, DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for bool where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for i8 where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for i16 where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for i32 where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for i64 where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for u8 where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for u16 where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for u32 where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for u64 where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for f32 where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for f64 where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for String where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<T, __ST, __DB> Queryable<__ST, __DB> for Vec<T> where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
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>,
[src]
T: 'a + ToOwned,
ST: SingleValue,
DB: Backend,
Self: FromSql<ST, DB>,
impl<A, __DB, SA> Queryable<(SA,), __DB> for (A,) where
__DB: Backend,
Self: FromStaticSqlRow<(SA,), __DB>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA,), __DB>,
impl<__T, __DB, SA> Queryable<Nullable<(SA,)>, __DB> for Option<__T> where
__DB: Backend,
Self: FromStaticSqlRow<Nullable<(SA,)>, __DB>,
(SA,): SqlType,
[src]
__DB: Backend,
Self: FromStaticSqlRow<Nullable<(SA,)>, __DB>,
(SA,): SqlType,
impl<A, B, __DB, SA, SB> Queryable<(SA, SB), __DB> for (A, B) where
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB), __DB>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB), __DB>,
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,
[src]
__DB: Backend,
Self: FromStaticSqlRow<Nullable<(SA, SB)>, __DB>,
(SA, SB): SqlType,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC), __DB>,
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,
[src]
__DB: Backend,
Self: FromStaticSqlRow<Nullable<(SA, SB, SC)>, __DB>,
(SA, SB, SC): SqlType,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD), __DB>,
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,
[src]
__DB: Backend,
Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD)>, __DB>,
(SA, SB, SC, SD): SqlType,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD, SE), __DB>,
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,
[src]
__DB: Backend,
Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE)>, __DB>,
(SA, SB, SC, SD, SE): SqlType,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF), __DB>,
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,
[src]
__DB: Backend,
Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF)>, __DB>,
(SA, SB, SC, SD, SE, SF): SqlType,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG), __DB>,
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,
[src]
__DB: Backend,
Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG)>, __DB>,
(SA, SB, SC, SD, SE, SF, SG): SqlType,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH), __DB>,
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,
[src]
__DB: Backend,
Self: FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH)>, __DB>,
(SA, SB, SC, SD, SE, SF, SG, SH): SqlType,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI), __DB>,
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,
[src]
__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,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ), __DB>,
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,
[src]
__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,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK), __DB>,
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,
[src]
__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,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL), __DB>,
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,
[src]
__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,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM), __DB>,
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,
[src]
__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,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN), __DB>,
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,
[src]
__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,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO), __DB>,
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,
[src]
__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,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP), __DB>,
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,
[src]
__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,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ), __DB>,
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,
[src]
__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,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR), __DB>,
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,
[src]
__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,
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>,
[src]
__DB: Backend,
Self: FromStaticSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS), __DB>,
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,
[src]
__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,
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>,
[src]
__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>,
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,
[src]
__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,
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>,
[src]
__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>,
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,
[src]
__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,
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>,
[src]
__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>,
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,
[src]
__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,
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>,
[src]
__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>,
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,
[src]
__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,
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>,
[src]
__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>,
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,
[src]
__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,
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>,
[src]
__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>,
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,
[src]
__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,
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>,
[src]
__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>,
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,
[src]
__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,
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>,
[src]
__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>,
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,
[src]
__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,
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>,
[src]
__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>,
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,
[src]
__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,
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>,
[src]
__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>,
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,
[src]
__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,
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>,
[src]
__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>,
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,
[src]
__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,
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>,
[src]
__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>,
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,
[src]
__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,
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>,
[src]
__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>,
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,
[src]
Loading content...__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,
Implementors
impl<__DB: Backend, __ST0, __ST1> Queryable<(__ST0, __ST1), __DB> for PgTypeMetadata where
(u32, u32): FromStaticSqlRow<(__ST0, __ST1), __DB>,
[src]
(u32, u32): FromStaticSqlRow<(__ST0, __ST1), __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for PgNumeric where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for PgMoney where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for PgDate where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for PgInterval where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for PgTime where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
impl<__ST, __DB> Queryable<__ST, __DB> for PgTimestamp where
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,
[src]
__DB: Backend,
__ST: SingleValue,
Self: FromSql<__ST, __DB>,