Struct diesel::pg::Pg

[+] Show declaration

pub struct Pg;

[−] Expand description

The PostgreSQL backend

Trait Implementations

impl HasSqlType<Bool> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<SmallInt> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Integer> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<BigInt> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Float> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Double> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Numeric> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Text> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Binary> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Date> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Interval> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Time> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Timestamp> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl<T> HasSqlType<Array<T>> for Pg where     Pg: HasSqlType<T>,

[+]

fn metadata(lookup: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl<T, ST> FromSql<Array<ST>, Pg> for Vec<T> where     T: FromSql<ST, Pg>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl<ST, T> ToSql<Array<ST>, Pg> for [T] where     Pg: HasSqlType<ST>,     T: ToSql<ST, Pg>,

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl<ST, T> ToSql<Nullable<Array<ST>>, Pg> for [T] where     [T]: ToSql<Array<ST>, Pg>,

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl<ST, T> ToSql<Array<ST>, Pg> for Vec<T> where     [T]: ToSql<Array<ST>, Pg>,     T: Debug,

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl<ST, T> ToSql<Nullable<Array<ST>>, Pg> for Vec<T> where     Vec<T>: ToSql<Array<ST>, Pg>,

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl FromSql<Timestamp, Pg> for NaiveDateTime

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl ToSql<Timestamp, Pg> for NaiveDateTime

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl FromSql<Timestamptz, Pg> for NaiveDateTime

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl ToSql<Timestamptz, Pg> for NaiveDateTime

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl FromSql<Timestamptz, Pg> for DateTime<Utc>

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl<TZ: TimeZone> ToSql<Timestamptz, Pg> for DateTime<TZ>

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl ToSql<Time, Pg> for NaiveTime

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl FromSql<Time, Pg> for NaiveTime

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl ToSql<Date, Pg> for NaiveDate

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl FromSql<Date, Pg> for NaiveDate

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl ToSql<Timestamp, Pg> for SystemTime

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl FromSql<Timestamp, Pg> for SystemTime

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl ToSql<Timestamp, Pg> for PgTimestamp

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl FromSql<Timestamp, Pg> for PgTimestamp

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl ToSql<Timestamptz, Pg> for PgTimestamp

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl FromSql<Timestamptz, Pg> for PgTimestamp

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl ToSql<Date, Pg> for PgDate

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl FromSql<Date, Pg> for PgDate

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl ToSql<Time, Pg> for PgTime

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl FromSql<Time, Pg> for PgTime

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl ToSql<Interval, Pg> for PgInterval

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl FromSql<Interval, Pg> for PgInterval

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl FromSql<Numeric, Pg> for PgNumeric

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl ToSql<Numeric, Pg> for PgNumeric

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl FromSql<Oid, Pg> for u32

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl ToSql<Oid, Pg> for u32

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl FromSql<Money, Pg> for PgMoney

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl ToSql<Money, Pg> for PgMoney

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl FromSql<Bool, Pg> for bool

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl ToSql<Bool, Pg> for bool

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

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

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self) -> Self

[−]

Construct an instance of this type

impl<T, ST> FromSqlRow<Range<ST>, Pg> for (Bound<T>, Bound<T>) where     (Bound<T>, Bound<T>): FromSql<Range<ST>, Pg>,

[+]

fn build_from_row<R: Row<Pg>>(row: &mut R) -> Result<Self>

[−]

See the trait documentation.

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

impl<T, ST> FromSql<Range<ST>, Pg> for (Bound<T>, Bound<T>) where     T: FromSql<ST, Pg>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl<ST, T> ToSql<Range<ST>, Pg> for (Bound<T>, Bound<T>) where     T: ToSql<ST, Pg>,

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl<ST, T> ToSql<Nullable<Range<ST>>, Pg> for (Bound<T>, Bound<T>) where     (Bound<T>, Bound<T>): ToSql<Range<ST>, Pg>,

[+]

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

[−]

See the trait documentation.

impl<A, SA> FromSql<Record<(SA,)>, Pg> for (A,) where     A: FromSql<SA, Pg>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl<A, SA> FromSqlRow<Record<(SA,)>, Pg> for (A,) where     Self: FromSql<Record<(SA,)>, Pg>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

impl<A, B, SA, SB> FromSql<Record<(SA, SB)>, Pg> for (A, B) where     A: FromSql<SA, Pg>,     B: FromSql<SB, Pg>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, SA, SB> FromSqlRow<Record<(SA, SB)>, Pg> for (A, B) where     Self: FromSql<Record<(SA, SB)>, Pg>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

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>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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> FromSqlRow<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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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> FromSqlRow<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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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> FromSqlRow<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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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> FromSqlRow<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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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> FromSqlRow<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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB)>, Pg> 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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC)>, Pg> 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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD)>, Pg> 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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE)>, Pg> 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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

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>,

[+]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

[−]

See the trait documentation.

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> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF)>, Pg> 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>,

[+]

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

[−]

See the trait documentation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF) where     Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF)>, Pg>,

[+]

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

[−]

Construct an instance of this type

impl HasSqlType<Oid> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Timestamptz> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl<ST> HasSqlType<Record<ST>> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Uuid> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Json> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Jsonb> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Money> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<MacAddr> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Inet> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl HasSqlType<Cidr> for Pg

[+]

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

[−]

Fetch the metadata for the given type

impl Debug for Pg

[+]

fn fmt(&self, f: &mut Formatter) -> Result

[−]

Formats the value using the given formatter.

impl Clone for Pg

[+]

fn clone(&self) -> Pg

[−]

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

[−]

Performs copy-assignment from source.

impl Copy for Pg

impl Hash for Pg

[+]

fn hash<__H: Hasher>(&self, state: &mut __H)

[−]

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

[−]

Feeds a slice of this type into the given [Hasher].

impl PartialEq for Pg

[+]

fn eq(&self, other: &Pg) -> bool

[−]

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

[−]

This method tests for !=.

impl Eq for Pg

impl Queryable<(Oid, Oid), Pg> for PgTypeMetadata

[+]

type Row = (u32, u32)

The Rust type you'd like to map from.

fn build((oid, array_oid): Self::Row) -> Self

[−]

Construct an instance of this type

impl Backend for Pg

type QueryBuilder = PgQueryBuilder

The concrete QueryBuilder implementation for this backend.

type BindCollector = RawBytesBindCollector<Pg>

The concrete BindCollector implementation for this backend.

type RawValue = [u8]

The raw representation of a database value given to FromSql.

type ByteOrder = NetworkEndian

What byte order is used to transmit integers?

impl TypeMetadata for Pg

type TypeMetadata = PgTypeMetadata

The actual type used to represent metadata.

type MetadataLookup = PgMetadataLookup

The type used for runtime lookup of metadata.

impl SupportsReturningClause for Pg

impl SupportsDefaultKeyword for Pg

impl UsesAnsiSavepointSyntax for Pg

impl<T> QueryFragment<Pg> for DistinctOnClause<T> where     T: QueryFragment<Pg>,

[+]

fn walk_ast(&self, out: AstPass<Pg>) -> QueryResult<()>

[−]

Walk over this QueryFragment for all passes.

fn to_sql(&self, out: &mut DB::QueryBuilder) -> QueryResult<()>

[−]

Converts this QueryFragment to its SQL representation.

fn collect_binds(     &self,     out: &mut DB::BindCollector,     metadata_lookup: &DB::MetadataLookup ) -> QueryResult<()>

[−]

Serializes all bind parameters in this query.

fn is_safe_to_cache_prepared(&self) -> QueryResult<bool>

[−]

Is this query safe to store in the prepared statement cache?

impl QueryBuilder<Pg> for PgQueryBuilder

[+]

fn push_sql(&mut self, sql: &str)

[−]

Add sql to the end of the query being constructed.

fn push_identifier(&mut self, identifier: &str) -> QueryResult<()>

[−]

Quote identifier, and add it to the end of the query being constructed.

fn push_bind_param(&mut self)

[−]

Add a placeholder for a bind parameter to the end of the query being constructed.

fn finish(self) -> String

[−]

Returns the constructed SQL query.

impl<'a> QueryFragment<Pg> for TransactionBuilder<'a>

[+]

fn walk_ast(&self, out: AstPass<Pg>) -> QueryResult<()>

[−]

Walk over this QueryFragment for all passes.

fn to_sql(&self, out: &mut DB::QueryBuilder) -> QueryResult<()>

[−]

Converts this QueryFragment to its SQL representation.

fn collect_binds(     &self,     out: &mut DB::BindCollector,     metadata_lookup: &DB::MetadataLookup ) -> QueryResult<()>

[−]

Serializes all bind parameters in this query.

fn is_safe_to_cache_prepared(&self) -> QueryResult<bool>

[−]

Is this query safe to store in the prepared statement cache?