Trait diesel::deserialize::FromSql
source · [−]pub trait FromSql<A, DB: Backend>: Sized {
fn from_sql(bytes: Option<&DB::RawValue>) -> Result<Self>;
}
Expand description
Deserialize a single field of a given SQL type.
When possible, implementations of this trait should prefer to use an
existing implementation, rather than reading from bytes
. (For example, if
you are implementing this for an enum which is represented as an integer in
the database, prefer i32::from_sql(bytes)
over reading from bytes
directly)
Types which implement this trait should also have #[derive(FromSqlRow)]
Backend specific details
- For PostgreSQL, the bytes will be sent using the binary protocol, not text.
- For SQLite, the actual type of
DB::RawValue
is private API. All implementations of this trait must be written in terms of an existing primitive. - For MySQL, the value of
bytes
will depend on the return value oftype_metadata
for the given SQL type. SeeMysqlType
for details. - For third party backends, consult that backend’s documentation.
Examples
Most implementations of this trait will be defined in terms of an existing implementation.
#[repr(i32)]
#[derive(Debug, Clone, Copy)]
pub enum MyEnum {
A = 1,
B = 2,
}
impl<DB> FromSql<Integer, DB> for MyEnum
where
DB: Backend,
i32: FromSql<Integer, DB>,
{
fn from_sql(bytes: Option<&DB::RawValue>) -> deserialize::Result<Self> {
match i32::from_sql(bytes)? {
1 => Ok(MyEnum::A),
2 => Ok(MyEnum::B),
x => Err(format!("Unrecognized variant {}", x).into()),
}
}
}
Required methods
Implementations on Foreign Types
sourceimpl FromSql<Timestamp, Pg> for SystemTime
impl FromSql<Timestamp, Pg> for SystemTime
sourceimpl<A, B, SA, SB> FromSql<Record<(SA, SB)>, Pg> for (A, B) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
impl<A, B, SA, SB> FromSql<Record<(SA, SB)>, Pg> for (A, B) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
sourceimpl<A, B, C, SA, SB, SC> FromSql<Record<(SA, SB, SC)>, Pg> for (A, B, C) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
impl<A, B, C, SA, SB, SC> FromSql<Record<(SA, SB, SC)>, Pg> for (A, B, C) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
sourceimpl<A, B, C, D, SA, SB, SC, SD> FromSql<Record<(SA, SB, SC, SD)>, Pg> for (A, B, C, D) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
impl<A, B, C, D, SA, SB, SC, SD> FromSql<Record<(SA, SB, SC, SD)>, Pg> for (A, B, C, D) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
sourceimpl<A, B, C, D, E, SA, SB, SC, SD, SE> FromSql<Record<(SA, SB, SC, SD, SE)>, Pg> for (A, B, C, D, E) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
impl<A, B, C, D, E, SA, SB, SC, SD, SE> FromSql<Record<(SA, SB, SC, SD, SE)>, Pg> for (A, B, C, D, E) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
sourceimpl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF> FromSql<Record<(SA, SB, SC, SD, SE, SF)>, Pg> for (A, B, C, D, E, F) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF> FromSql<Record<(SA, SB, SC, SD, SE, SF)>, Pg> for (A, B, C, D, E, F) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
sourceimpl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg> for (A, B, C, D, E, F, G) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg> for (A, B, C, D, E, F, G) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
sourceimpl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg> for (A, B, C, D, E, F, G, H) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg> for (A, B, C, D, E, F, G, H) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
sourceimpl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg> for (A, B, C, D, E, F, G, H, I) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg> for (A, B, C, D, E, F, G, H, I) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
sourceimpl<A, B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, Pg> for (A, B, C, D, E, F, G, H, I, J) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
impl<A, B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, Pg> for (A, B, C, D, E, F, G, H, I, J) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
sourceimpl<A, B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
impl<A, B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
sourceimpl<A, B, C, D, E, F, G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, 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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
sourceimpl<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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, 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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
sourceimpl<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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, 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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
sourceimpl<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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, 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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
sourceimpl<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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, 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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
sourceimpl<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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, 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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
sourceimpl<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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, 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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
sourceimpl<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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, 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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
sourceimpl<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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, 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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
sourceimpl<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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, 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> FromSql<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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
sourceimpl<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> 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> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<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, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV> 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> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
sourceimpl<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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<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, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
sourceimpl<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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<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, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
sourceimpl<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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<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, 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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<SY, Pg>,
sourceimpl<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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<SY, Pg>,
Z: FromSql<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, 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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<SY, Pg>,
Z: FromSql<SZ, Pg>,
sourceimpl<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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<SY, Pg>,
Z: FromSql<SZ, Pg>,
AA: FromSql<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, 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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<SY, Pg>,
Z: FromSql<SZ, Pg>,
AA: FromSql<SAA, Pg>,
sourceimpl<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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<SY, Pg>,
Z: FromSql<SZ, Pg>,
AA: FromSql<SAA, Pg>,
AB: FromSql<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, 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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<SY, Pg>,
Z: FromSql<SZ, Pg>,
AA: FromSql<SAA, Pg>,
AB: FromSql<SAB, Pg>,
sourceimpl<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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<SY, Pg>,
Z: FromSql<SZ, Pg>,
AA: FromSql<SAA, Pg>,
AB: FromSql<SAB, Pg>,
AC: FromSql<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, 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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<SY, Pg>,
Z: FromSql<SZ, Pg>,
AA: FromSql<SAA, Pg>,
AB: FromSql<SAB, Pg>,
AC: FromSql<SAC, Pg>,
sourceimpl<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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<SY, Pg>,
Z: FromSql<SZ, Pg>,
AA: FromSql<SAA, Pg>,
AB: FromSql<SAB, Pg>,
AC: FromSql<SAC, Pg>,
AD: FromSql<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, 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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<SY, Pg>,
Z: FromSql<SZ, Pg>,
AA: FromSql<SAA, Pg>,
AB: FromSql<SAB, Pg>,
AC: FromSql<SAC, Pg>,
AD: FromSql<SAD, Pg>,
sourceimpl<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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<SY, Pg>,
Z: FromSql<SZ, Pg>,
AA: FromSql<SAA, Pg>,
AB: FromSql<SAB, Pg>,
AC: FromSql<SAC, Pg>,
AD: FromSql<SAD, Pg>,
AE: FromSql<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, 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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<SY, Pg>,
Z: FromSql<SZ, Pg>,
AA: FromSql<SAA, Pg>,
AB: FromSql<SAB, Pg>,
AC: FromSql<SAC, Pg>,
AD: FromSql<SAD, Pg>,
AE: FromSql<SAE, Pg>,
sourceimpl<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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<SY, Pg>,
Z: FromSql<SZ, Pg>,
AA: FromSql<SAA, Pg>,
AB: FromSql<SAB, Pg>,
AC: FromSql<SAC, Pg>,
AD: FromSql<SAD, Pg>,
AE: FromSql<SAE, Pg>,
AF: FromSql<SAF, 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> 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> 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
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, Pg>,
E: FromSql<SE, Pg>,
F: FromSql<SF, Pg>,
G: FromSql<SG, Pg>,
H: FromSql<SH, Pg>,
I: FromSql<SI, Pg>,
J: FromSql<SJ, Pg>,
K: FromSql<SK, Pg>,
L: FromSql<SL, Pg>,
M: FromSql<SM, Pg>,
N: FromSql<SN, Pg>,
O: FromSql<SO, Pg>,
P: FromSql<SP, Pg>,
Q: FromSql<SQ, Pg>,
R: FromSql<SR, Pg>,
S: FromSql<SS, Pg>,
T: FromSql<ST, Pg>,
U: FromSql<SU, Pg>,
V: FromSql<SV, Pg>,
W: FromSql<SW, Pg>,
X: FromSql<SX, Pg>,
Y: FromSql<SY, Pg>,
Z: FromSql<SZ, Pg>,
AA: FromSql<SAA, Pg>,
AB: FromSql<SAB, Pg>,
AC: FromSql<SAC, Pg>,
AD: FromSql<SAD, Pg>,
AE: FromSql<SAE, Pg>,
AF: FromSql<SAF, Pg>,
sourceimpl<T, ST, DB> FromSql<Nullable<ST>, DB> for Option<T> where
T: FromSql<ST, DB>,
DB: Backend,
ST: NotNull,
impl<T, ST, DB> FromSql<Nullable<ST>, DB> for Option<T> where
T: FromSql<ST, DB>,
DB: Backend,
ST: NotNull,
sourceimpl<DB: Backend<RawValue = [u8]>> FromSql<Text, DB> for *const str
impl<DB: Backend<RawValue = [u8]>> FromSql<Text, DB> for *const str
The returned pointer is only valid for the lifetime to the argument of
from_sql
. This impl is intended for uses where you want to write a new
impl in terms of String
, but don’t want to allocate. We have to return a
raw pointer instead of a reference with a lifetime due to the structure of
FromSql
sourceimpl<DB: Backend<RawValue = [u8]>> FromSql<Binary, DB> for *const [u8]
impl<DB: Backend<RawValue = [u8]>> FromSql<Binary, DB> for *const [u8]
The returned pointer is only valid for the lifetime to the argument of
from_sql
. This impl is intended for uses where you want to write a new
impl in terms of Vec<u8>
, but don’t want to allocate. We have to return a
raw pointer instead of a reference with a lifetime due to the structure of
FromSql