[−][src]Struct diesel::pg::types::sql_types::Record
The Record
(a.k.a. tuple) SQL type.
ToSql
impls
- Any tuple which can be serialized to each of the elements (note: There are major caveats, see the section below)
FromSql
impls
- Any tuple which can be deserialized from each of the elements.
Caveats about serialization
Typically in the documentation for SQL types, we use "FromSql
impls"
as a shorthand for "Rust types that you can use to represent this type".
For every other type, that means there is specifically an implementation
of the FromSql
trait.
However, PostgreSQL does not support transmission of anonymous record
types as bind parameters. It only supports transmission for named
composite types. For this reason, if you tried to do
int_tuple_col.eq((1, 2))
, we will generate the SQL int_tuple_col = ($1, $2)
rather than int_tuple_col = $1
as we would for anything
else.
This should not be visible during normal usage. The only time this would
affect you is if you were attempting to use sql_query
with tuples.
Your code would not compile in that case, as the ToSql
trait itself is
not implemented.
You can implement ToSql
for named composite types. See WriteTuple
for details.
Trait Implementations
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> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>> for (A, B, C, D, E, F, G, H, I, J, K, L) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>> for (A, B, C, D, E, F, G, H, I, J, K) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>> for (A, B, C, D, E, F, G, H, I, J) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>> for (A, B, C, D, E, F, G, H, I) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>> for (A, B, C, D, E, F, G, H) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG)>> for (A, B, C, D, E, F, G) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF> AsExpression<Record<(SA, SB, SC, SD, SE, SF)>> for (A, B, C, D, E, F) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, SA, SB, SC, SD, SE> AsExpression<Record<(SA, SB, SC, SD, SE)>> for (A, B, C, D, E) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, SA, SB, SC, SD> AsExpression<Record<(SA, SB, SC, SD)>> for (A, B, C, D) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, SA, SB, SC> AsExpression<Record<(SA, SB, SC)>> for (A, B, C) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
PgTuple<(A::Expression, B::Expression, C::Expression)>: Expression<SqlType = Record<(SA, SB, SC)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
PgTuple<(A::Expression, B::Expression, C::Expression)>: Expression<SqlType = Record<(SA, SB, SC)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, SA, SB> AsExpression<Record<(SA, SB)>> for (A, B) where
A: AsExpression<SA>,
B: AsExpression<SB>,
PgTuple<(A::Expression, B::Expression)>: Expression<SqlType = Record<(SA, SB)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
PgTuple<(A::Expression, B::Expression)>: Expression<SqlType = Record<(SA, SB)>>,
type Expression = PgTuple<(A::Expression, B::Expression)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<A, SA> AsExpression<Record<(SA,)>> for (A,) where
A: AsExpression<SA>,
PgTuple<(A::Expression,)>: Expression<SqlType = Record<(SA,)>>,
[src]
A: AsExpression<SA>,
PgTuple<(A::Expression,)>: Expression<SqlType = Record<(SA,)>>,
type Expression = PgTuple<(A::Expression,)>
The expression being returned
fn as_expression(self) -> Self::Expression
[src]
impl<ST: Clone> Clone for Record<ST>
[src]
impl<ST: Copy> Copy for Record<ST>
[src]
impl<ST: Debug> Debug for Record<ST>
[src]
impl<ST: Default> Default for Record<ST>
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> 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>,
[src]
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, 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>,
[src]
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, 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>,
[src]
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, 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>,
[src]
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, 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>,
[src]
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, 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>,
[src]
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, 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>,
[src]
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, 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>,
[src]
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, 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>,
[src]
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, 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>,
[src]
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, 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>,
[src]
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, 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>,
[src]
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, 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>,
[src]
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
D: FromSql<SD, 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>,
[src]
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
C: FromSql<SC, Pg>,
impl<A, B, SA, SB> FromSql<Record<(SA, SB)>, Pg> for (A, B) where
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
[src]
A: FromSql<SA, Pg>,
B: FromSql<SB, Pg>,
impl<A, SA> FromSql<Record<(SA,)>, Pg> for (A,) where
A: FromSql<SA, Pg>,
[src]
A: FromSql<SA, 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> FromSqlRow<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>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> FromSqlRow<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>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> FromSqlRow<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>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> FromSqlRow<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>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> FromSqlRow<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>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> FromSqlRow<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>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<A, B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> FromSqlRow<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>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> FromSqlRow<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>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> FromSqlRow<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>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> FromSqlRow<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>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF> FromSqlRow<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>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<A, B, C, D, E, SA, SB, SC, SD, SE> FromSqlRow<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>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<A, B, C, D, SA, SB, SC, SD> FromSqlRow<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>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<A, B, C, SA, SB, SC> FromSqlRow<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>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<A, B, SA, SB> FromSqlRow<Record<(SA, SB)>, Pg> for (A, B) where
Self: FromSql<Record<(SA, SB)>, Pg>,
[src]
Self: FromSql<Record<(SA, SB)>, Pg>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<A, SA> FromSqlRow<Record<(SA,)>, Pg> for (A,) where
Self: FromSql<Record<(SA,)>, Pg>,
[src]
Self: FromSql<Record<(SA,)>, Pg>,
const FIELDS_NEEDED: usize
[src]
fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>
[src]
impl<ST> HasSqlType<Record<ST>> for Pg
[src]
fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata
[src]
impl<ST> NotNull for Record<ST>
[src]
impl<ST: QueryId> QueryId for Record<ST>
[src]
type QueryId = Record<<ST as QueryId>::QueryId>
A type which uniquely represents Self
in a SQL query. Read more
const HAS_STATIC_QUERY_ID: bool
[src]
fn query_id() -> Option<TypeId>
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L) where
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K) where
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<A, B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, Pg> for (A, B, C, D, E, F, G, H, I, J) where
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg> for (A, B, C, D, E, F, G, H, I) where
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg> for (A, B, C, D, E, F, G, H) where
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg> for (A, B, C, D, E, F, G) where
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF> Queryable<Record<(SA, SB, SC, SD, SE, SF)>, Pg> for (A, B, C, D, E, F) where
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<A, B, C, D, E, SA, SB, SC, SD, SE> Queryable<Record<(SA, SB, SC, SD, SE)>, Pg> for (A, B, C, D, E) where
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA, SB, SC, SD, SE)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<A, B, C, D, SA, SB, SC, SD> Queryable<Record<(SA, SB, SC, SD)>, Pg> for (A, B, C, D) where
Self: FromSqlRow<Record<(SA, SB, SC, SD)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA, SB, SC, SD)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<A, B, C, SA, SB, SC> Queryable<Record<(SA, SB, SC)>, Pg> for (A, B, C) where
Self: FromSqlRow<Record<(SA, SB, SC)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA, SB, SC)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<A, B, SA, SB> Queryable<Record<(SA, SB)>, Pg> for (A, B) where
Self: FromSqlRow<Record<(SA, SB)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA, SB)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<A, SA> Queryable<Record<(SA,)>, Pg> for (A,) where
Self: FromSqlRow<Record<(SA,)>, Pg>,
[src]
Self: FromSqlRow<Record<(SA,)>, Pg>,
type Row = Self
The Rust type you'd like to map from. Read more
fn build(row: Self::Row) -> Self
[src]
impl<ST> SingleValue for Record<ST>
[src]
Auto Trait Implementations
impl<ST> RefUnwindSafe for Record<ST> where
ST: RefUnwindSafe,
ST: RefUnwindSafe,
impl<ST> Send for Record<ST> where
ST: Send,
ST: Send,
impl<ST> Sync for Record<ST> where
ST: Sync,
ST: Sync,
impl<ST> Unpin for Record<ST> where
ST: Unpin,
ST: Unpin,
impl<ST> UnwindSafe for Record<ST> where
ST: UnwindSafe,
ST: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> IntoNullable for T where
T: NotNull,
[src]
T: NotNull,
impl<T> IntoSql for T
[src]
fn into_sql<T>(self) -> AsExprOf<Self, T> where
Self: AsExpression<T> + Sized,
[src]
Self: AsExpression<T> + Sized,
fn as_sql<'a, T>(&'a self) -> AsExprOf<&'a Self, T> where
&'a Self: AsExpression<T>,
[src]
&'a Self: AsExpression<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,