diesel/pg/types/
mod.rs

1//! PostgreSQL specific types
2
3mod array;
4#[doc(hidden)]
5pub(in crate::pg) mod date_and_time;
6#[doc(hidden)]
7pub(in crate::pg) mod floats;
8mod integers;
9#[cfg(feature = "ipnet-address")]
10mod ipnet_address;
11#[cfg(feature = "serde_json")]
12mod json;
13mod json_function_enum;
14mod mac_addr;
15mod mac_addr_8;
16#[doc(hidden)]
17pub(in crate::pg) mod money;
18mod multirange;
19#[cfg(feature = "network-address")]
20mod network_address;
21mod numeric;
22pub(in crate::pg) mod pg_lsn;
23mod primitives;
24mod ranges;
25mod record;
26#[cfg(feature = "uuid")]
27mod uuid;
28
29/// PostgreSQL specific SQL types
30///
31/// Note: All types in this module can be accessed through `diesel::sql_types`
32pub mod sql_types {
33    use crate::query_builder::QueryId;
34    use crate::sql_types::SqlType;
35
36    /// The [`OID`] SQL type. This is a PostgreSQL specific type.
37    ///
38    /// ### [`ToSql`] impls
39    ///
40    /// - [`u32`]
41    ///
42    /// ### [`FromSql`] impls
43    ///
44    /// - [`u32`]
45    ///
46    /// [`ToSql`]: crate::serialize::ToSql
47    /// [`FromSql`]: crate::deserialize::FromSql
48    /// [`u32`]: https://doc.rust-lang.org/nightly/std/primitive.u32.html
49    /// [`OID`]: https://www.postgresql.org/docs/current/datatype-oid.html
50    #[cfg(feature = "postgres_backend")]
51    #[derive(#[automatically_derived]
impl ::core::fmt::Debug for Oid {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Oid")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Oid {
    #[inline]
    fn clone(&self) -> Oid { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Oid { }Copy, #[automatically_derived]
impl ::core::default::Default for Oid {
    #[inline]
    fn default() -> Oid { Oid {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Oid {
            type QueryId = Oid<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Oid {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Oid {}
        use diesel::pg::{PgMetadataLookup, PgTypeMetadata};
        impl diesel::sql_types::HasSqlType<Oid> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup) -> PgTypeMetadata {
                PgTypeMetadata::new(26, 1028)
            }
        }
    };SqlType)]
52    #[diesel(postgres_type(oid = 26, array_oid = 1028))]
53    pub struct Oid;
54
55    /// The ["timestamp with time zone" SQL type][tz], which PostgreSQL abbreviates
56    /// to `timestamptz`.
57    ///
58    /// ### [`ToSql`] impls
59    ///
60    /// - [`PgTimestamp`]
61    /// - [`chrono::NaiveDateTime`] with `feature = "chrono"`
62    /// - [`chrono::DateTime`] with `feature = "chrono"`
63    /// - [`time::PrimitiveDateTime`] with `feature = "time"`
64    /// - [`time::OffsetDateTime`] with `feature = "time"`
65    ///
66    /// ### [`FromSql`] impls
67    ///
68    /// - [`PgTimestamp`]
69    /// - [`chrono::NaiveDateTime`] with `feature = "chrono"`
70    /// - [`chrono::DateTime`] with `feature = "chrono"`
71    /// - [`time::PrimitiveDateTime`] with `feature = "time"`
72    /// - [`time::OffsetDateTime`] with `feature = "time"`
73    ///
74    /// [`ToSql`]: crate::serialize::ToSql
75    /// [`FromSql`]: crate::deserialize::FromSql
76    /// [`PgTimestamp`]: super::super::data_types::PgTimestamp
77    /// [tz]: https://www.postgresql.org/docs/current/datatype-datetime.html
78    #[cfg_attr(
79        feature = "chrono",
80        doc = " [`chrono::NaiveDateTime`]: chrono::naive::NaiveDateTime"
81    )]
82    #[cfg_attr(
83        not(feature = "chrono"),
84        doc = " [`chrono::NaiveDateTime`]: https://docs.rs/chrono/0.4.19/chrono/naive/struct.NaiveDateTime.html"
85    )]
86    #[cfg_attr(feature = "chrono", doc = " [`chrono::DateTime`]: chrono::DateTime")]
87    #[cfg_attr(
88        not(feature = "chrono"),
89        doc = " [`chrono::DateTime`]: https://docs.rs/chrono/0.4.19/chrono/struct.DateTime.html"
90    )]
91    #[cfg_attr(
92        feature = "time",
93        doc = " [`time::PrimitiveDateTime`]: time::PrimitiveDateTime"
94    )]
95    #[cfg_attr(
96        not(feature = "time"),
97        doc = " [`time::PrimitiveDateTime`]: https://docs.rs/time/0.3.9/time/struct.PrimitiveDateTime.html"
98    )]
99    #[cfg_attr(
100        feature = "time",
101        doc = " [`time::OffsetDateTime`]: time::OffsetDateTime"
102    )]
103    #[cfg_attr(
104        not(feature = "time"),
105        doc = " [`time::OffsetDateTime`]: https://docs.rs/time/0.3.9/time/struct.OffsetDateTime.html"
106    )]
107    #[cfg(feature = "postgres_backend")]
108    #[derive(#[automatically_derived]
impl ::core::fmt::Debug for Timestamptz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Timestamptz")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Timestamptz {
    #[inline]
    fn clone(&self) -> Timestamptz { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Timestamptz { }Copy, #[automatically_derived]
impl ::core::default::Default for Timestamptz {
    #[inline]
    fn default() -> Timestamptz { Timestamptz {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Timestamptz {
            type QueryId = Timestamptz<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Timestamptz {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Timestamptz {}
        use diesel::pg::{PgMetadataLookup, PgTypeMetadata};
        impl diesel::sql_types::HasSqlType<Timestamptz> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup) -> PgTypeMetadata {
                PgTypeMetadata::new(1184, 1185)
            }
        }
    };SqlType)]
109    #[diesel(postgres_type(oid = 1184, array_oid = 1185))]
110    pub struct Timestamptz;
111
112    /// The [`Array`] SQL type.
113    ///
114    /// This wraps another type to represent a SQL array of that type.
115    /// Multidimensional arrays are not supported.
116    ///
117    /// ### [`ToSql`] impls
118    ///
119    /// - [`Vec<T>`][Vec] for any `T` which implements `ToSql<ST>`
120    /// - [`&[T]`][slice] for any `T` which implements `ToSql<ST>`
121    ///
122    /// ### [`FromSql`] impls
123    ///
124    /// - [`Vec<T>`][Vec] for any `T` which implements `ToSql<ST>`
125    ///
126    /// [`ToSql`]: crate::serialize::ToSql
127    /// [`FromSql`]: crate::deserialize::FromSql
128    /// [Vec]: std::vec::Vec
129    /// [slice]: https://doc.rust-lang.org/nightly/std/primitive.slice.html
130    /// [`Array`]: https://www.postgresql.org/docs/current/arrays.html
131    #[derive(#[automatically_derived]
impl<ST: ::core::fmt::Debug + 'static> ::core::fmt::Debug for Array<ST> {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Array",
            &&self.0)
    }
}Debug, #[automatically_derived]
impl<ST: ::core::clone::Clone + 'static> ::core::clone::Clone for Array<ST> {
    #[inline]
    fn clone(&self) -> Array<ST> {
        Array(::core::clone::Clone::clone(&self.0))
    }
}Clone, #[automatically_derived]
impl<ST: ::core::marker::Copy + 'static> ::core::marker::Copy for Array<ST> {
}Copy, #[automatically_derived]
impl<ST: ::core::default::Default + 'static> ::core::default::Default for
    Array<ST> {
    #[inline]
    fn default() -> Array<ST> { Array(::core::default::Default::default()) }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl<ST: 'static + diesel::query_builder::QueryId>
            diesel::query_builder::QueryId for Array<ST> {
            type QueryId =
                Array<<ST as diesel::query_builder::QueryId>::QueryId>;
            const HAS_STATIC_QUERY_ID: bool =
                <ST as diesel::query_builder::QueryId>::HAS_STATIC_QUERY_ID &&
                    true;
            const IS_WINDOW_FUNCTION: bool =
                <ST as diesel::query_builder::QueryId>::IS_WINDOW_FUNCTION ||
                    false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl<ST: 'static> diesel::sql_types::SqlType for Array<ST> {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = true;
        }
        impl<ST: 'static> diesel::sql_types::SingleValue for Array<ST> {}
    };SqlType)]
132    #[cfg(feature = "postgres_backend")]
133    pub struct Array<ST: 'static>(ST);
134
135    /// The [`Range`] SQL type.
136    ///
137    /// This wraps another type to represent a SQL range of that type.
138    ///
139    /// ### [`ToSql`] impls
140    ///
141    /// - [`(Bound<T>, Bound<T>)`][bound] for any `T` which implements `ToSql<ST>`.
142    /// - [`Range<T>`][std::range] (aka `start..end`) for any `T` which implements `ToSql<ST>`.
143    /// - [`RangeInclusive<T>`] (aka `start..=end`) for any `T` which implements `ToSql<ST>`.
144    /// - [`RangeFrom<T>`] (aka `start..`) for any `T` which implements `ToSql<ST>`.
145    /// - [`RangeTo<T>`] (aka `..end`) for any `T` which implements `ToSql<ST>`.
146    /// - [`RangeToInclusive<T>`] (aka `..=end`) for any `T` which implements `ToSql<ST>`.
147    ///
148    /// ### [`FromSql`] impls
149    ///
150    /// - [`(Bound<T>, Bound<T>)`][bound] for any `T` which implements `FromSql<ST>`.
151    ///
152    /// [`ToSql`]: crate::serialize::ToSql
153    /// [`FromSql`]: crate::deserialize::FromSql
154    /// [bound]: std::collections::Bound
155    /// [std::range]: std::ops::Range
156    /// [`RangeInclusive<T>`]: std::ops::RangeInclusive
157    /// [`RangeFrom<T>`]: std::ops::RangeFrom
158    /// [`RangeTo<T>`]: std::ops::RangeTo
159    /// [`RangeToInclusive<T>`]: std::ops::RangeToInclusive
160    /// [`Range`]: https://www.postgresql.org/docs/current/rangetypes.html
161    #[derive(#[automatically_derived]
impl<ST: ::core::fmt::Debug + 'static> ::core::fmt::Debug for Range<ST> {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Range",
            &&self.0)
    }
}Debug, #[automatically_derived]
impl<ST: ::core::clone::Clone + 'static> ::core::clone::Clone for Range<ST> {
    #[inline]
    fn clone(&self) -> Range<ST> {
        Range(::core::clone::Clone::clone(&self.0))
    }
}Clone, #[automatically_derived]
impl<ST: ::core::marker::Copy + 'static> ::core::marker::Copy for Range<ST> {
}Copy, #[automatically_derived]
impl<ST: ::core::default::Default + 'static> ::core::default::Default for
    Range<ST> {
    #[inline]
    fn default() -> Range<ST> { Range(::core::default::Default::default()) }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl<ST: 'static + diesel::query_builder::QueryId>
            diesel::query_builder::QueryId for Range<ST> {
            type QueryId =
                Range<<ST as diesel::query_builder::QueryId>::QueryId>;
            const HAS_STATIC_QUERY_ID: bool =
                <ST as diesel::query_builder::QueryId>::HAS_STATIC_QUERY_ID &&
                    true;
            const IS_WINDOW_FUNCTION: bool =
                <ST as diesel::query_builder::QueryId>::IS_WINDOW_FUNCTION ||
                    false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl<ST: 'static> diesel::sql_types::SqlType for Range<ST> {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl<ST: 'static> diesel::sql_types::SingleValue for Range<ST> {}
    };SqlType)]
162    #[cfg(feature = "postgres_backend")]
163    pub struct Range<ST: 'static>(ST);
164
165    #[doc(hidden)]
166    pub type Int4range = Range<crate::sql_types::Int4>;
167    #[doc(hidden)]
168    pub type Int8range = Range<crate::sql_types::Int8>;
169    #[doc(hidden)]
170    pub type Daterange = Range<crate::sql_types::Date>;
171    #[doc(hidden)]
172    pub type Numrange = Range<crate::sql_types::Numeric>;
173    #[doc(hidden)]
174    pub type Tsrange = Range<crate::sql_types::Timestamp>;
175    #[doc(hidden)]
176    pub type Tstzrange = Range<crate::sql_types::Timestamptz>;
177
178    /// The [`Multirange`] SQL type.
179    ///
180    /// This wraps another type to represent a SQL range of that type.
181    ///
182    /// ### [`ToSql`] impls
183    ///
184    /// - [`Vec<T>`][Vec] for any `T` which `Range<T>` implements `ToSql<ST>`
185    /// - [`&[T]`][slice] for any `T` which `Range<T>` implements `ToSql<ST>`
186    ///
187    /// ### [`FromSql`] impls
188    ///
189    /// - [`Vec<T>`][Vec] for any `T` which implements `ToSql<Range<ST>>`
190    ///
191    /// [`ToSql`]: crate::serialize::ToSql
192    /// [`FromSql`]: crate::deserialize::FromSql
193    /// [Vec]: std::vec::Vec
194    /// [slice]: https://doc.rust-lang.org/nightly/std/primitive.slice.html
195    /// [`Multirange`]: https://www.postgresql.org/docs/current/rangetypes.html
196    #[derive(#[automatically_derived]
impl<ST: ::core::fmt::Debug + 'static> ::core::fmt::Debug for Multirange<ST> {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Multirange",
            &&self.0)
    }
}Debug, #[automatically_derived]
impl<ST: ::core::clone::Clone + 'static> ::core::clone::Clone for
    Multirange<ST> {
    #[inline]
    fn clone(&self) -> Multirange<ST> {
        Multirange(::core::clone::Clone::clone(&self.0))
    }
}Clone, #[automatically_derived]
impl<ST: ::core::marker::Copy + 'static> ::core::marker::Copy for
    Multirange<ST> {
}Copy, #[automatically_derived]
impl<ST: ::core::default::Default + 'static> ::core::default::Default for
    Multirange<ST> {
    #[inline]
    fn default() -> Multirange<ST> {
        Multirange(::core::default::Default::default())
    }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl<ST: 'static + diesel::query_builder::QueryId>
            diesel::query_builder::QueryId for Multirange<ST> {
            type QueryId =
                Multirange<<ST as diesel::query_builder::QueryId>::QueryId>;
            const HAS_STATIC_QUERY_ID: bool =
                <ST as diesel::query_builder::QueryId>::HAS_STATIC_QUERY_ID &&
                    true;
            const IS_WINDOW_FUNCTION: bool =
                <ST as diesel::query_builder::QueryId>::IS_WINDOW_FUNCTION ||
                    false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl<ST: 'static> diesel::sql_types::SqlType for Multirange<ST> {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl<ST: 'static> diesel::sql_types::SingleValue for Multirange<ST> {}
    };SqlType)]
197    #[cfg(feature = "postgres_backend")]
198    pub struct Multirange<ST: 'static>(ST);
199
200    #[doc(hidden)]
201    pub type Int4multirange = Multirange<crate::sql_types::Int4>;
202    #[doc(hidden)]
203    pub type Int8multirange = Multirange<crate::sql_types::Int8>;
204    #[doc(hidden)]
205    pub type Datemultirange = Multirange<crate::sql_types::Date>;
206    #[doc(hidden)]
207    pub type Nummultirange = Multirange<crate::sql_types::Numeric>;
208    #[doc(hidden)]
209    pub type Tsmultirange = Multirange<crate::sql_types::Timestamp>;
210    #[doc(hidden)]
211    pub type Tstzmultirange = Multirange<crate::sql_types::Timestamptz>;
212
213    /// This is a wrapper for [`NullValueTreatment`] to represent null_value_treatment for jsonb_seet_lax:
214    ///     'raise_exception' 'use_json_null' 'delete_key' 'return_target'
215    /// used in functions jsonb_set_lax
216    #[derive(#[automatically_derived]
impl ::core::fmt::Debug for NullValueTreatmentEnum {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "NullValueTreatmentEnum")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for NullValueTreatmentEnum {
    #[inline]
    fn clone(&self) -> NullValueTreatmentEnum { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for NullValueTreatmentEnum { }Copy, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for NullValueTreatmentEnum {
            type QueryId = NullValueTreatmentEnum<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for NullValueTreatmentEnum {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for NullValueTreatmentEnum {}
        use diesel::pg::{PgMetadataLookup, PgTypeMetadata};
        impl diesel::sql_types::HasSqlType<NullValueTreatmentEnum> for
            diesel::pg::Pg {
            fn metadata(lookup: &mut Self::MetadataLookup) -> PgTypeMetadata {
                lookup.lookup_type("text", None)
            }
        }
    };SqlType)]
217    #[cfg(feature = "postgres_backend")]
218    #[diesel(postgres_type(name = "text"))]
219    pub struct NullValueTreatmentEnum;
220
221    /// Represent null_value_treatment for jsonb_seet_lax:
222    ///     'raise_exception' 'use_json_null' 'delete_key' 'return_target'
223    /// used in functions jsonb_seet_lax.
224    #[derive(#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::fmt::Debug for NullValueTreatment {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                NullValueTreatment::RaiseException => "RaiseException",
                NullValueTreatment::UseJsonNull => "UseJsonNull",
                NullValueTreatment::DeleteKey => "DeleteKey",
                NullValueTreatment::ReturnTarget => "ReturnTarget",
            })
    }
}Debug, #[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::clone::Clone for NullValueTreatment {
    #[inline]
    fn clone(&self) -> NullValueTreatment { *self }
}Clone, #[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::marker::Copy for NullValueTreatment { }Copy, const _: () =
    {
        use diesel;
        impl<'__expr> diesel::expression::AsExpression<NullValueTreatmentEnum>
            for &'__expr NullValueTreatment {
            type Expression =
                diesel::internal::derives::as_expression::Bound<NullValueTreatmentEnum,
                Self>;
            fn as_expression(self)
                ->
                    <Self as
                    diesel::expression::AsExpression<NullValueTreatmentEnum>>::Expression {
                diesel::internal::derives::as_expression::Bound::new(self)
            }
        }
        impl<'__expr>
            diesel::expression::AsExpression<diesel::sql_types::Nullable<NullValueTreatmentEnum>>
            for &'__expr NullValueTreatment {
            type Expression =
                diesel::internal::derives::as_expression::Bound<diesel::sql_types::Nullable<NullValueTreatmentEnum>,
                Self>;
            fn as_expression(self)
                ->
                    <Self as
                    diesel::expression::AsExpression<diesel::sql_types::Nullable<NullValueTreatmentEnum>>>::Expression {
                diesel::internal::derives::as_expression::Bound::new(self)
            }
        }
        impl<'__expr, '__expr2>
            diesel::expression::AsExpression<NullValueTreatmentEnum> for
            &'__expr2 &'__expr NullValueTreatment {
            type Expression =
                diesel::internal::derives::as_expression::Bound<NullValueTreatmentEnum,
                Self>;
            fn as_expression(self)
                ->
                    <Self as
                    diesel::expression::AsExpression<NullValueTreatmentEnum>>::Expression {
                diesel::internal::derives::as_expression::Bound::new(self)
            }
        }
        impl<'__expr, '__expr2>
            diesel::expression::AsExpression<diesel::sql_types::Nullable<NullValueTreatmentEnum>>
            for &'__expr2 &'__expr NullValueTreatment {
            type Expression =
                diesel::internal::derives::as_expression::Bound<diesel::sql_types::Nullable<NullValueTreatmentEnum>,
                Self>;
            fn as_expression(self)
                ->
                    <Self as
                    diesel::expression::AsExpression<diesel::sql_types::Nullable<NullValueTreatmentEnum>>>::Expression {
                diesel::internal::derives::as_expression::Bound::new(self)
            }
        }
        impl<__DB>
            diesel::serialize::ToSql<diesel::sql_types::Nullable<NullValueTreatmentEnum>,
            __DB> for NullValueTreatment where __DB: diesel::backend::Backend,
            Self: diesel::serialize::ToSql<NullValueTreatmentEnum, __DB> {
            fn to_sql<'__b>(&'__b self,
                out: &mut diesel::serialize::Output<'__b, '_, __DB>)
                -> diesel::serialize::Result {
                diesel::serialize::ToSql::<NullValueTreatmentEnum,
                        __DB>::to_sql(self, out)
            }
        }
        impl diesel::expression::AsExpression<NullValueTreatmentEnum> for
            NullValueTreatment {
            type Expression =
                diesel::internal::derives::as_expression::Bound<NullValueTreatmentEnum,
                Self>;
            fn as_expression(self)
                ->
                    <Self as
                    diesel::expression::AsExpression<NullValueTreatmentEnum>>::Expression {
                diesel::internal::derives::as_expression::Bound::new(self)
            }
        }
        impl diesel::expression::AsExpression<diesel::sql_types::Nullable<NullValueTreatmentEnum>>
            for NullValueTreatment {
            type Expression =
                diesel::internal::derives::as_expression::Bound<diesel::sql_types::Nullable<NullValueTreatmentEnum>,
                Self>;
            fn as_expression(self)
                ->
                    <Self as
                    diesel::expression::AsExpression<diesel::sql_types::Nullable<NullValueTreatmentEnum>>>::Expression {
                diesel::internal::derives::as_expression::Bound::new(self)
            }
        }
    };diesel_derives::AsExpression)]
225    #[diesel(sql_type = NullValueTreatmentEnum)]
226    #[allow(clippy::enum_variant_names)]
227    pub enum NullValueTreatment {
228        /// postgres 'raise_exception'
229        RaiseException,
230        /// postgres 'use_json_null'
231        UseJsonNull,
232        /// postgres 'delete_key'
233        DeleteKey,
234        /// postgres 'return_target'
235        ReturnTarget,
236    }
237
238    /// This is a wrapper for [`RangeBound`] to represent range bounds: '[]', '(]', '[)', '()',
239    /// used in functions int4range, int8range, numrange, tsrange, tstzrange, daterange.
240    #[derive(#[automatically_derived]
impl ::core::fmt::Debug for RangeBoundEnum {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "RangeBoundEnum")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for RangeBoundEnum {
    #[inline]
    fn clone(&self) -> RangeBoundEnum { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for RangeBoundEnum { }Copy, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for RangeBoundEnum {
            type QueryId = RangeBoundEnum<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for RangeBoundEnum {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for RangeBoundEnum {}
        use diesel::pg::{PgMetadataLookup, PgTypeMetadata};
        impl diesel::sql_types::HasSqlType<RangeBoundEnum> for diesel::pg::Pg
            {
            fn metadata(lookup: &mut Self::MetadataLookup) -> PgTypeMetadata {
                lookup.lookup_type("text", None)
            }
        }
    };SqlType)]
241    #[cfg(feature = "postgres_backend")]
242    #[diesel(postgres_type(name = "text"))]
243    pub struct RangeBoundEnum;
244
245    /// Represent postgres range bounds: '[]', '(]', '[)', '()',
246    /// used in functions int4range, int8range, numrange, tsrange, tstzrange, daterange.
247    #[derive(#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::fmt::Debug for RangeBound {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                RangeBound::LowerBoundInclusiveUpperBoundInclusive =>
                    "LowerBoundInclusiveUpperBoundInclusive",
                RangeBound::LowerBoundInclusiveUpperBoundExclusive =>
                    "LowerBoundInclusiveUpperBoundExclusive",
                RangeBound::LowerBoundExclusiveUpperBoundInclusive =>
                    "LowerBoundExclusiveUpperBoundInclusive",
                RangeBound::LowerBoundExclusiveUpperBoundExclusive =>
                    "LowerBoundExclusiveUpperBoundExclusive",
            })
    }
}Debug, #[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::clone::Clone for RangeBound {
    #[inline]
    fn clone(&self) -> RangeBound { *self }
}Clone, #[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::marker::Copy for RangeBound { }Copy, const _: () =
    {
        use diesel;
        impl<'__expr> diesel::expression::AsExpression<RangeBoundEnum> for
            &'__expr RangeBound {
            type Expression =
                diesel::internal::derives::as_expression::Bound<RangeBoundEnum,
                Self>;
            fn as_expression(self)
                ->
                    <Self as
                    diesel::expression::AsExpression<RangeBoundEnum>>::Expression {
                diesel::internal::derives::as_expression::Bound::new(self)
            }
        }
        impl<'__expr>
            diesel::expression::AsExpression<diesel::sql_types::Nullable<RangeBoundEnum>>
            for &'__expr RangeBound {
            type Expression =
                diesel::internal::derives::as_expression::Bound<diesel::sql_types::Nullable<RangeBoundEnum>,
                Self>;
            fn as_expression(self)
                ->
                    <Self as
                    diesel::expression::AsExpression<diesel::sql_types::Nullable<RangeBoundEnum>>>::Expression {
                diesel::internal::derives::as_expression::Bound::new(self)
            }
        }
        impl<'__expr, '__expr2>
            diesel::expression::AsExpression<RangeBoundEnum> for
            &'__expr2 &'__expr RangeBound {
            type Expression =
                diesel::internal::derives::as_expression::Bound<RangeBoundEnum,
                Self>;
            fn as_expression(self)
                ->
                    <Self as
                    diesel::expression::AsExpression<RangeBoundEnum>>::Expression {
                diesel::internal::derives::as_expression::Bound::new(self)
            }
        }
        impl<'__expr, '__expr2>
            diesel::expression::AsExpression<diesel::sql_types::Nullable<RangeBoundEnum>>
            for &'__expr2 &'__expr RangeBound {
            type Expression =
                diesel::internal::derives::as_expression::Bound<diesel::sql_types::Nullable<RangeBoundEnum>,
                Self>;
            fn as_expression(self)
                ->
                    <Self as
                    diesel::expression::AsExpression<diesel::sql_types::Nullable<RangeBoundEnum>>>::Expression {
                diesel::internal::derives::as_expression::Bound::new(self)
            }
        }
        impl<__DB>
            diesel::serialize::ToSql<diesel::sql_types::Nullable<RangeBoundEnum>,
            __DB> for RangeBound where __DB: diesel::backend::Backend,
            Self: diesel::serialize::ToSql<RangeBoundEnum, __DB> {
            fn to_sql<'__b>(&'__b self,
                out: &mut diesel::serialize::Output<'__b, '_, __DB>)
                -> diesel::serialize::Result {
                diesel::serialize::ToSql::<RangeBoundEnum,
                        __DB>::to_sql(self, out)
            }
        }
        impl diesel::expression::AsExpression<RangeBoundEnum> for RangeBound {
            type Expression =
                diesel::internal::derives::as_expression::Bound<RangeBoundEnum,
                Self>;
            fn as_expression(self)
                ->
                    <Self as
                    diesel::expression::AsExpression<RangeBoundEnum>>::Expression {
                diesel::internal::derives::as_expression::Bound::new(self)
            }
        }
        impl diesel::expression::AsExpression<diesel::sql_types::Nullable<RangeBoundEnum>>
            for RangeBound {
            type Expression =
                diesel::internal::derives::as_expression::Bound<diesel::sql_types::Nullable<RangeBoundEnum>,
                Self>;
            fn as_expression(self)
                ->
                    <Self as
                    diesel::expression::AsExpression<diesel::sql_types::Nullable<RangeBoundEnum>>>::Expression {
                diesel::internal::derives::as_expression::Bound::new(self)
            }
        }
    };diesel_derives::AsExpression)]
248    #[diesel(sql_type = RangeBoundEnum)]
249    #[allow(clippy::enum_variant_names)]
250    pub enum RangeBound {
251        /// postgres '[]'
252        LowerBoundInclusiveUpperBoundInclusive,
253        /// postgres '[)'
254        LowerBoundInclusiveUpperBoundExclusive,
255        /// postgres '(]'
256        LowerBoundExclusiveUpperBoundInclusive,
257        /// postgres '()'
258        LowerBoundExclusiveUpperBoundExclusive,
259    }
260
261    /// The [`Record`] (a.k.a. tuple) SQL type.
262    ///
263    /// ### [`ToSql`] impls
264    ///
265    /// - Any tuple which can be serialized to each of the elements
266    ///   (note: There are major caveats, see the section below)
267    ///
268    /// ### [`FromSql`] impls
269    ///
270    /// - Any tuple which can be deserialized from each of the elements.
271    ///
272    /// [`ToSql`]: crate::serialize::ToSql
273    /// [`FromSql`]: crate::deserialize::FromSql
274    ///
275    /// ### Caveats about serialization
276    ///
277    /// Typically in the documentation for SQL types, we use "`FromSql` impls"
278    /// as a shorthand for "Rust types that you can use to represent this type".
279    /// For every other type, that means there is specifically an implementation
280    /// of the `FromSql` trait.
281    ///
282    /// However, PostgreSQL does not support transmission of anonymous record
283    /// types as bind parameters. It only supports transmission for named
284    /// composite types. For this reason, if you tried to do
285    /// `int_tuple_col.eq((1, 2))`, we will generate the SQL `int_tuple_col =
286    /// ($1, $2)` rather than `int_tuple_col = $1` as we would for anything
287    /// else.
288    ///
289    /// This should not be visible during normal usage. The only time this would
290    /// affect you is if you were attempting to use `sql_query` with tuples.
291    /// Your code would not compile in that case, as the `ToSql` trait itself is
292    /// not implemented.
293    ///
294    /// You can implement `ToSql` for named composite types. See [`WriteTuple`]
295    /// for details.
296    ///
297    /// [`WriteTuple`]: super::super::super::serialize::WriteTuple
298    /// [`Record`]: https://www.postgresql.org/docs/current/rowtypes.html
299    #[cfg(feature = "postgres_backend")]
300    #[derive(#[automatically_derived]
impl<ST: ::core::fmt::Debug + 'static> ::core::fmt::Debug for Record<ST> {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Record",
            &&self.0)
    }
}Debug, #[automatically_derived]
impl<ST: ::core::clone::Clone + 'static> ::core::clone::Clone for Record<ST> {
    #[inline]
    fn clone(&self) -> Record<ST> {
        Record(::core::clone::Clone::clone(&self.0))
    }
}Clone, #[automatically_derived]
impl<ST: ::core::marker::Copy + 'static> ::core::marker::Copy for Record<ST> {
}Copy, #[automatically_derived]
impl<ST: ::core::default::Default + 'static> ::core::default::Default for
    Record<ST> {
    #[inline]
    fn default() -> Record<ST> { Record(::core::default::Default::default()) }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl<ST: 'static + diesel::query_builder::QueryId>
            diesel::query_builder::QueryId for Record<ST> {
            type QueryId =
                Record<<ST as diesel::query_builder::QueryId>::QueryId>;
            const HAS_STATIC_QUERY_ID: bool =
                <ST as diesel::query_builder::QueryId>::HAS_STATIC_QUERY_ID &&
                    true;
            const IS_WINDOW_FUNCTION: bool =
                <ST as diesel::query_builder::QueryId>::IS_WINDOW_FUNCTION ||
                    false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl<ST: 'static> diesel::sql_types::SqlType for Record<ST> {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl<ST: 'static> diesel::sql_types::SingleValue for Record<ST> {}
        use diesel::pg::{PgMetadataLookup, PgTypeMetadata};
        impl<ST: 'static> diesel::sql_types::HasSqlType<Record<ST>> for
            diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup) -> PgTypeMetadata {
                PgTypeMetadata::new(2249, 2287)
            }
        }
    };SqlType)]
301    #[diesel(postgres_type(oid = 2249, array_oid = 2287))]
302    pub struct Record<ST: 'static>(ST);
303
304    /// Alias for [`SmallInt`](crate::sql_types::SmallInt)
305    #[cfg(feature = "postgres_backend")]
306    pub type SmallSerial = crate::sql_types::SmallInt;
307
308    /// Alias for [`Integer`](crate::sql_types::Integer)
309    #[cfg(feature = "postgres_backend")]
310    pub type Serial = crate::sql_types::Integer;
311
312    /// Alias for [`BigInt`](crate::sql_types::BigInt)
313    #[cfg(feature = "postgres_backend")]
314    pub type BigSerial = crate::sql_types::BigInt;
315
316    /// The [`UUID`] SQL type. This type can only be used with `feature = "uuid"`
317    ///
318    /// ### [`ToSql`] impls
319    ///
320    /// - [`uuid::Uuid`][Uuid]
321    ///
322    /// ### [`FromSql`] impls
323    ///
324    /// - [`uuid::Uuid`][Uuid]
325    ///
326    /// [`ToSql`]: crate::serialize::ToSql
327    /// [`FromSql`]: crate::deserialize::FromSql
328    /// [Uuid]: https://docs.rs/uuid/*/uuid/struct.Uuid.html
329    /// [`UUID`]: https://www.postgresql.org/docs/current/datatype-uuid.html
330    #[cfg(feature = "postgres_backend")]
331    #[derive(#[automatically_derived]
impl ::core::fmt::Debug for Uuid {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Uuid")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Uuid {
    #[inline]
    fn clone(&self) -> Uuid { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Uuid { }Copy, #[automatically_derived]
impl ::core::default::Default for Uuid {
    #[inline]
    fn default() -> Uuid { Uuid {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Uuid {
            type QueryId = Uuid<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Uuid {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Uuid {}
        use diesel::pg::{PgMetadataLookup, PgTypeMetadata};
        impl diesel::sql_types::HasSqlType<Uuid> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup) -> PgTypeMetadata {
                PgTypeMetadata::new(2950, 2951)
            }
        }
    };SqlType)]
332    #[diesel(postgres_type(oid = 2950, array_oid = 2951))]
333    pub struct Uuid;
334
335    /// Alias for `Binary`, to ensure `diesel print-schema` works
336    pub type Bytea = crate::sql_types::Binary;
337
338    #[doc(hidden)]
339    pub type Bpchar = crate::sql_types::VarChar;
340
341    /// The PostgreSQL [Money](https://www.postgresql.org/docs/current/static/datatype-money.html) type.
342    ///
343    /// ### [`ToSql`] impls
344    ///
345    /// - [`Cents` (also aliased as `PgMoney`)][PgMoney]
346    ///
347    /// ### [`FromSql`] impls
348    ///
349    /// - [`Cents` (also aliased as `PgMoney`)][PgMoney]
350    ///
351    /// [`ToSql`]: crate::serialize::ToSql
352    /// [`FromSql`]: crate::deserialize::FromSql
353    /// [PgMoney]: crate::data_types::PgMoney
354    ///
355    /// # Examples
356    ///
357    /// ```rust
358    /// # include!("../../doctest_setup.rs");
359    /// use diesel::data_types::Cents;
360    ///
361    /// table! {
362    ///     items {
363    ///         id -> Integer,
364    ///         name -> VarChar,
365    ///         price -> Money,
366    ///     }
367    /// }
368    ///
369    /// # fn main() {
370    /// #     use diesel::insert_into;
371    /// #     use self::items::dsl::*;
372    /// #     let connection = &mut connection_no_data();
373    /// #     diesel::sql_query("CREATE TABLE items (
374    /// #         id SERIAL PRIMARY KEY,
375    /// #         name VARCHAR NOT NULL,
376    /// #         price MONEY NOT NULL
377    /// #     )").execute(connection).unwrap();
378    /// let inserted_price = insert_into(items)
379    ///     .values((name.eq("Shiny Thing"), price.eq(Cents(123_456))))
380    ///     .returning(price)
381    ///     .get_result(connection);
382    /// assert_eq!(Ok(Cents(123_456)), inserted_price);
383    /// # }
384    /// ```
385    #[cfg(feature = "postgres_backend")]
386    #[derive(#[automatically_derived]
impl ::core::fmt::Debug for Money {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Money")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Money {
    #[inline]
    fn clone(&self) -> Money { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Money { }Copy, #[automatically_derived]
impl ::core::default::Default for Money {
    #[inline]
    fn default() -> Money { Money {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Money {
            type QueryId = Money<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Money {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Money {}
        use diesel::pg::{PgMetadataLookup, PgTypeMetadata};
        impl diesel::sql_types::HasSqlType<Money> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup) -> PgTypeMetadata {
                PgTypeMetadata::new(790, 791)
            }
        }
    };SqlType)]
387    #[diesel(postgres_type(oid = 790, array_oid = 791))]
388    pub struct Money;
389
390    /// The [`MACADDR`](https://www.postgresql.org/docs/current/static/datatype-net-types.html) SQL type.
391    ///
392    /// ### [`ToSql`] impls
393    ///
394    /// - `[u8; 6]`
395    ///
396    /// ### [`FromSql`] impls
397    ///
398    /// - `[u8; 6]`
399    ///
400    /// [`ToSql`]: crate::serialize::ToSql
401    /// [`FromSql`]: crate::deserialize::FromSql
402    ///
403    /// # Examples
404    ///
405    /// ```rust
406    /// # include!("../../doctest_setup.rs");
407    /// table! {
408    ///     devices {
409    ///         id -> Integer,
410    ///         macaddr -> MacAddr,
411    ///     }
412    /// }
413    ///
414    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
415    /// #     use diesel::insert_into;
416    /// #     use self::devices::dsl::*;
417    /// #     let connection = &mut connection_no_data();
418    /// #     diesel::sql_query("CREATE TABLE devices (
419    /// #         id SERIAL PRIMARY KEY,
420    /// #         macaddr MACADDR NOT NULL
421    /// #     )").execute(connection)?;
422    /// let inserted_macaddr = insert_into(devices)
423    ///     .values(macaddr.eq([0x08, 0x00, 0x2b, 0x01, 0x02, 0x03]))
424    ///     .returning(macaddr)
425    ///     .get_result::<[u8; 6]>(connection)?;
426    /// assert_eq!([0x08, 0x00, 0x2b, 0x01, 0x02, 0x03], inserted_macaddr);
427    /// #     Ok(())
428    /// # }
429    /// ```
430    #[cfg(feature = "postgres_backend")]
431    #[derive(#[automatically_derived]
impl ::core::fmt::Debug for MacAddr {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "MacAddr")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for MacAddr {
    #[inline]
    fn clone(&self) -> MacAddr { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for MacAddr { }Copy, #[automatically_derived]
impl ::core::default::Default for MacAddr {
    #[inline]
    fn default() -> MacAddr { MacAddr {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for MacAddr {
            type QueryId = MacAddr<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for MacAddr {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for MacAddr {}
        use diesel::pg::{PgMetadataLookup, PgTypeMetadata};
        impl diesel::sql_types::HasSqlType<MacAddr> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup) -> PgTypeMetadata {
                PgTypeMetadata::new(829, 1040)
            }
        }
    };SqlType)]
432    #[diesel(postgres_type(oid = 829, array_oid = 1040))]
433    pub struct MacAddr;
434
435    /// Alias for `MacAddr` to be able to use it with `diesel print-schema`.
436    pub type Macaddr = MacAddr;
437
438    /// The [`MACADDR8`](https://www.postgresql.org/docs/current/static/datatype-net-types.html) SQL type.
439    ///
440    /// ### [`ToSql`] impls
441    ///
442    /// - `[u8; 8]`
443    ///
444    /// ### [`FromSql`] impls
445    ///
446    /// - `[u8; 8]`
447    ///
448    /// [`ToSql`]: crate::serialize::ToSql
449    /// [`FromSql`]: crate::deserialize::FromSql
450    ///
451    /// # Examples
452    ///
453    /// ```rust
454    /// # include!("../../doctest_setup.rs");
455    /// table! {
456    ///     devices {
457    ///         id -> Integer,
458    ///         macaddr -> MacAddr8,
459    ///     }
460    /// }
461    ///
462    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
463    /// #     use diesel::insert_into;
464    /// #     use self::devices::dsl::*;
465    /// #     let connection = &mut connection_no_data();
466    /// #     diesel::sql_query("CREATE TABLE devices (
467    /// #         id SERIAL PRIMARY KEY,
468    /// #         macaddr MACADDR8 NOT NULL
469    /// #     )").execute(connection)?;
470    /// let inserted_macaddr = insert_into(devices)
471    ///     .values(macaddr.eq([0x08, 0x00, 0x2b, 0x01, 0x02, 0x03, 0x04, 0x05]))
472    ///     .returning(macaddr)
473    ///     .get_result::<[u8; 8]>(connection)?;
474    /// assert_eq!(
475    ///     [0x08, 0x00, 0x2b, 0x01, 0x02, 0x03, 0x04, 0x05],
476    ///     inserted_macaddr
477    /// );
478    /// #     Ok(())
479    /// # }
480    /// ```
481    #[cfg(feature = "postgres_backend")]
482    #[derive(#[automatically_derived]
impl ::core::fmt::Debug for MacAddr8 {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "MacAddr8")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for MacAddr8 {
    #[inline]
    fn clone(&self) -> MacAddr8 { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for MacAddr8 { }Copy, #[automatically_derived]
impl ::core::default::Default for MacAddr8 {
    #[inline]
    fn default() -> MacAddr8 { MacAddr8 {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for MacAddr8 {
            type QueryId = MacAddr8<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for MacAddr8 {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for MacAddr8 {}
        use diesel::pg::{PgMetadataLookup, PgTypeMetadata};
        impl diesel::sql_types::HasSqlType<MacAddr8> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup) -> PgTypeMetadata {
                PgTypeMetadata::new(774, 775)
            }
        }
    };SqlType)]
483    #[diesel(postgres_type(oid = 774, array_oid = 775))]
484    pub struct MacAddr8;
485
486    /// Alias for `MacAddr` to be able to use it with `diesel print-schema`.
487    pub type Macaddr8 = MacAddr8;
488
489    /// The [`INET`](https://www.postgresql.org/docs/current/static/datatype-net-types.html) SQL type. This type can only be used with `feature = "network-address"` or `feature = "ipnet-address"`.
490    ///
491    /// ### [`ToSql`] impls
492    #[cfg_attr(
493        feature = "network-address",
494        doc = " - [`ipnetwork::IpNetwork`][IpNetwork]"
495    )]
496    #[cfg_attr(feature = "ipnet-address", doc = " - [`ipnet::IpNet`][IpNet]")]
497    #[cfg_attr(
498        not(any(feature = "network-address", feature = "ipnet-address")),
499        doc = "N/A"
500    )]
501    ///
502    /// ### [`FromSql`] impls
503    #[cfg_attr(
504        feature = "network-address",
505        doc = " - [`ipnetwork::IpNetwork`][IpNetwork]"
506    )]
507    #[cfg_attr(feature = "ipnet-address", doc = " - [`ipnet::IpNet`][IpNet]")]
508    #[cfg_attr(
509        not(any(feature = "network-address", feature = "ipnet-address")),
510        doc = "N/A"
511    )]
512    ///
513    /// [`ToSql`]: crate::serialize::ToSql
514    /// [`FromSql`]: crate::deserialize::FromSql
515    #[cfg_attr(
516        feature = "network-address",
517        doc = " [IpNetwork]: ipnetwork::IpNetwork"
518    )]
519    #[cfg_attr(feature = "ipnet-address", doc = " [IpNet]: ipnet::IpNet")]
520    ///
521    /// # Examples
522    ///
523    /// ```rust
524    /// # include!("../../doctest_setup.rs");
525    /// #
526    /// table! {
527    ///     clients {
528    ///         id -> Integer,
529    ///         ip_address -> Inet,
530    ///     }
531    /// }
532    ///
533    /// # #[cfg(any(feature = "network-address", feature = "ipnet-address"))]
534    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
535    ///
536    /// #     use diesel::insert_into;
537    /// #     use self::clients::dsl::*;
538    /// #     let connection = &mut connection_no_data();
539    /// #     diesel::sql_query("CREATE TABLE clients (
540    /// #         id SERIAL PRIMARY KEY,
541    /// #         ip_address INET NOT NULL
542    /// #     )").execute(connection)?;
543    /// // Parsing "ipnet::IpNet" would also work.
544    /// let addr = "10.1.9.32/32".parse::<ipnetwork::IpNetwork>()?;
545    /// let inserted_address = insert_into(clients)
546    ///     .values(ip_address.eq(&addr))
547    ///     .returning(ip_address)
548    ///     .get_result(connection)?;
549    /// assert_eq!(addr, inserted_address);
550    /// #     Ok(())
551    /// # }
552    /// #
553    /// # #[cfg(not(any(feature = "network-address", feature = "ipnet-address")))]
554    /// # fn main() {}
555    /// ```
556    #[cfg(feature = "postgres_backend")]
557    #[derive(#[automatically_derived]
impl ::core::fmt::Debug for Inet {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Inet")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Inet {
    #[inline]
    fn clone(&self) -> Inet { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Inet { }Copy, #[automatically_derived]
impl ::core::default::Default for Inet {
    #[inline]
    fn default() -> Inet { Inet {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Inet {
            type QueryId = Inet<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Inet {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Inet {}
        use diesel::pg::{PgMetadataLookup, PgTypeMetadata};
        impl diesel::sql_types::HasSqlType<Inet> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup) -> PgTypeMetadata {
                PgTypeMetadata::new(869, 1041)
            }
        }
    };SqlType)]
558    #[diesel(postgres_type(oid = 869, array_oid = 1041))]
559    pub struct Inet;
560
561    /// The [`CIDR`](https://www.postgresql.org/docs/postgresql/static/datatype-net-types.html) SQL type. This type can only be used with `feature = "network-address"` or `feature = "ipnet-address"`.
562    ///
563    /// ### [`ToSql`] impls
564    #[cfg_attr(
565        feature = "network-address",
566        doc = " - [`ipnetwork::IpNetwork`][IpNetwork]"
567    )]
568    #[cfg_attr(feature = "ipnet-address", doc = " - [`ipnet::IpNet`][IpNet]")]
569    #[cfg_attr(
570        not(any(feature = "network-address", feature = "ipnet-address")),
571        doc = "N/A"
572    )]
573    ///
574    /// ### [`FromSql`] impls
575    #[cfg_attr(
576        feature = "network-address",
577        doc = " - [`ipnetwork::IpNetwork`][IpNetwork]"
578    )]
579    #[cfg_attr(feature = "ipnet-address", doc = " - [`ipnet::IpNet`][IpNet]")]
580    #[cfg_attr(
581        not(any(feature = "network-address", feature = "ipnet-address")),
582        doc = "N/A"
583    )]
584    ///
585    /// [`ToSql`]: crate::serialize::ToSql
586    /// [`FromSql`]: crate::deserialize::FromSql
587    #[cfg_attr(
588        feature = "network-address",
589        doc = " [IpNetwork]: ipnetwork::IpNetwork"
590    )]
591    #[cfg_attr(feature = "ipnet-address", doc = " [IpNet]: ipnet::IpNet")]
592    ///
593    /// # Examples
594    ///
595    /// ```rust
596    /// # #![allow(dead_code)]
597    /// # include!("../../doctest_setup.rs");
598    /// table! {
599    ///     clients {
600    ///         id -> Integer,
601    ///         ip_address -> Cidr,
602    ///     }
603    /// }
604    ///
605    /// # #[cfg(any(feature = "network-address", feature = "ipnet-address"))]
606    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
607    ///
608    /// #     use diesel::insert_into;
609    /// #     use self::clients::dsl::*;
610    /// #     let connection = &mut connection_no_data();
611    /// #     diesel::sql_query("CREATE TABLE clients (
612    /// #         id SERIAL PRIMARY KEY,
613    /// #         ip_address CIDR NOT NULL
614    /// #     )").execute(connection)?;
615    /// // Parsing "ipnet::IpNet" would also work.
616    /// let addr = "10.1.9.32/32".parse::<ipnetwork::IpNetwork>()?;
617    /// let inserted_addr = insert_into(clients)
618    ///     .values(ip_address.eq(&addr))
619    ///     .returning(ip_address)
620    ///     .get_result(connection)?;
621    /// assert_eq!(addr, inserted_addr);
622    /// #     Ok(())
623    /// # }
624    /// # #[cfg(not(any(feature = "network-address", feature = "ipnet-address")))]
625    /// # fn main() {}
626    /// ```
627    #[cfg(feature = "postgres_backend")]
628    #[derive(#[automatically_derived]
impl ::core::fmt::Debug for Cidr {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Cidr")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Cidr {
    #[inline]
    fn clone(&self) -> Cidr { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Cidr { }Copy, #[automatically_derived]
impl ::core::default::Default for Cidr {
    #[inline]
    fn default() -> Cidr { Cidr {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Cidr {
            type QueryId = Cidr<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Cidr {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Cidr {}
        use diesel::pg::{PgMetadataLookup, PgTypeMetadata};
        impl diesel::sql_types::HasSqlType<Cidr> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup) -> PgTypeMetadata {
                PgTypeMetadata::new(650, 651)
            }
        }
    };SqlType)]
629    #[diesel(postgres_type(oid = 650, array_oid = 651))]
630    pub struct Cidr;
631
632    /// The [`"char"`] SQL type. This is a PostgreSQL specific type. Used for e.g. [setweight]. [Do not use in user tables].
633    ///
634    /// ### [`ToSql`] impls
635    ///
636    /// - [`u8`]
637    ///
638    /// ### [`FromSql`] impls
639    ///
640    /// - [`u8`]
641    ///
642    /// [`ToSql`]: crate::serialize::ToSql
643    /// [`FromSql`]: crate::deserialize::FromSql
644    /// [`u8`]: https://doc.rust-lang.org/nightly/std/primitive.u8.html
645    /// [`"char"`]: https://www.postgresql.org/docs/current/datatype-character.html#DATATYPE-CHARACTER-SPECIAL-TABLE
646    /// [setweight]: https://www.postgresql.org/docs/current/functions-textsearch.html
647    /// [Do not use in user tables]: https://www.postgresql.org/docs/current/datatype-character.html#DATATYPE-CHARACTER-SPECIAL-TABLE
648    #[cfg(feature = "postgres_backend")]
649    #[derive(#[automatically_derived]
impl ::core::fmt::Debug for CChar {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "CChar")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for CChar {
    #[inline]
    fn clone(&self) -> CChar { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for CChar { }Copy, #[automatically_derived]
impl ::core::default::Default for CChar {
    #[inline]
    fn default() -> CChar { CChar {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for CChar {
            type QueryId = CChar<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for CChar {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for CChar {}
        use diesel::pg::{PgMetadataLookup, PgTypeMetadata};
        impl diesel::sql_types::HasSqlType<CChar> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup) -> PgTypeMetadata {
                PgTypeMetadata::new(18, 1002)
            }
        }
    };SqlType)]
650    #[diesel(postgres_type(oid = 18, array_oid = 1002))]
651    pub struct CChar;
652
653    /// The [`Citext`] SQL type. This is a PostgreSQL specific type.
654    ///
655    /// Strings must be valid UTF-8.
656    ///
657    /// ### [`ToSql`] impls
658    ///
659    /// - [`String`]
660    /// - [`&str`][str]
661    ///
662    /// ### [`FromSql`] impls
663    ///
664    /// - [`String`]
665    ///
666    /// [`ToSql`]: crate::serialize::ToSql
667    /// [`FromSql`]: crate::deserialize::FromSql
668    /// [`Citext`]: https://www.postgresql.org/docs/current/citext.html
669    #[cfg(feature = "postgres_backend")]
670    #[derive(#[automatically_derived]
impl ::core::fmt::Debug for Citext {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Citext")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Citext {
    #[inline]
    fn clone(&self) -> Citext { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Citext { }Copy, #[automatically_derived]
impl ::core::default::Default for Citext {
    #[inline]
    fn default() -> Citext { Citext {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Citext {
            type QueryId = Citext<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Citext {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Citext {}
        use diesel::pg::{PgMetadataLookup, PgTypeMetadata};
        impl diesel::sql_types::HasSqlType<Citext> for diesel::pg::Pg {
            fn metadata(lookup: &mut Self::MetadataLookup) -> PgTypeMetadata {
                lookup.lookup_type("citext", None)
            }
        }
    };SqlType)]
671    #[diesel(postgres_type(name = "citext"))]
672    pub struct Citext;
673
674    /// The [`pg_lsn`] SQL type. This is a PostgreSQL specific type. Encodes a position in the PostgreSQL *Write Ahead Log* (WAL).
675    ///
676    /// ### [`ToSql`] impls
677    ///
678    /// - [`u64`]
679    ///
680    /// ### [`FromSql`] impls
681    ///
682    /// - [`u64`]
683    ///
684    /// [`ToSql`]: crate::serialize::ToSql
685    /// [`FromSql`]: crate::deserialize::FromSql
686    /// [`u64`]: https://doc.rust-lang.org/nightly/std/primitive.u64.html
687    /// [`pg_lsn`]: https://www.postgresql.org/docs/current/datatype-pg-lsn.html
688    #[cfg(feature = "postgres_backend")]
689    #[derive(#[automatically_derived]
impl ::core::fmt::Debug for PgLsn {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "PgLsn")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for PgLsn {
    #[inline]
    fn clone(&self) -> PgLsn { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for PgLsn { }Copy, #[automatically_derived]
impl ::core::default::Default for PgLsn {
    #[inline]
    fn default() -> PgLsn { PgLsn {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for PgLsn {
            type QueryId = PgLsn<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for PgLsn {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for PgLsn {}
        use diesel::pg::{PgMetadataLookup, PgTypeMetadata};
        impl diesel::sql_types::HasSqlType<PgLsn> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup) -> PgTypeMetadata {
                PgTypeMetadata::new(3220, 3221)
            }
        }
    };SqlType)]
690    #[diesel(postgres_type(oid = 3220, array_oid = 3221))]
691    pub struct PgLsn;
692
693    #[doc(inline)]
694    pub use crate::sql_types::Jsonb;
695}
696
697mod ops {
698    use super::sql_types::*;
699    use crate::sql_types::ops::*;
700    use crate::sql_types::{Bigint, Interval};
701
702    impl Add for Timestamptz {
703        type Rhs = Interval;
704        type Output = Timestamptz;
705    }
706
707    impl Sub for Timestamptz {
708        type Rhs = Interval;
709        type Output = Timestamptz;
710    }
711
712    impl Add for Cidr {
713        type Rhs = Bigint;
714        type Output = Inet;
715    }
716
717    impl Add for Inet {
718        type Rhs = Bigint;
719        type Output = Inet;
720    }
721
722    impl Sub for Cidr {
723        type Rhs = Bigint;
724        type Output = Inet;
725    }
726
727    impl Sub for Inet {
728        type Rhs = Bigint;
729        type Output = Inet;
730    }
731}
diesel/pg/types/mod.rs

diesel/pg/types/
mod.rs
