diesel/sql_types/
mod.rs

1//! Types which represent a SQL data type.
2//!
3//! The structs in this module are *only* used as markers to represent a SQL type.
4//! They should never be used in your structs.
5//! If you'd like to know the rust types which can be used for a given SQL type,
6//! see the documentation for that SQL type.
7//! Additional types may be provided by other crates.
8//!
9//! To see which SQL type can be used with a given Rust type,
10//! see the "Implementors" section of [`FromSql`].
11//!
12//! [`FromSql`]: super::deserialize::FromSql
13//!
14//! Any backend specific types are re-exported through this module
15
16mod fold;
17pub mod ops;
18mod ord;
19
20pub use self::fold::Foldable;
21pub use self::ord::SqlOrd;
22
23use crate::backend::Backend;
24use crate::expression::TypedExpressionType;
25use crate::query_builder::QueryId;
26
27/// The boolean SQL type.
28///
29/// On backends without a native boolean type,
30/// this is emulated with the smallest supported integer.
31///
32/// ### [`ToSql`](crate::serialize::ToSql) impls
33///
34/// - [`bool`][bool]
35///
36/// ### [`FromSql`](crate::deserialize::FromSql) impls
37///
38/// - [`bool`][bool]
39///
40/// [bool]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
41#[derive(#[automatically_derived]
impl ::core::fmt::Debug for Bool {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Bool")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Bool {
    #[inline]
    fn clone(&self) -> Bool { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Bool { }Copy, #[automatically_derived]
impl ::core::default::Default for Bool {
    #[inline]
    fn default() -> Bool { Bool {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Bool {
            type QueryId = Bool<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Bool {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Bool {}
        impl diesel::sql_types::HasSqlType<Bool> for diesel::sqlite::Sqlite {
            fn metadata(_: &mut ()) -> diesel::sqlite::SqliteType {
                diesel::sqlite::SqliteType::Integer
            }
        }
        impl diesel::sql_types::HasSqlType<Bool> for diesel::mysql::Mysql {
            fn metadata(_: &mut ()) -> diesel::mysql::MysqlType {
                diesel::mysql::MysqlType::Tiny
            }
        }
        impl diesel::sql_types::HasSqlType<Bool> for diesel::mariadb::Mariadb
            {
            fn metadata(_: &mut ()) -> diesel::mariadb::MariadbType {
                diesel::mariadb::MariadbType::Tiny
            }
        }
        impl diesel::sql_types::HasSqlType<Bool> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup)
                -> diesel::pg::PgTypeMetadata {
                diesel::pg::PgTypeMetadata::new(16, 1000)
            }
        }
    };SqlType)]
42#[diesel(postgres_type(oid = 16, array_oid = 1000))]
43#[diesel(sqlite_type(name = "Integer"))]
44#[diesel(mysql_type(name = "Tiny"))]
45#[diesel(mariadb_type(name = "Tiny"))]
46pub struct Bool;
47
48/// The tiny integer SQL type.
49///
50/// This is only available on MySQL.
51/// Keep in mind that `diesel print-schema` will see `TINYINT(1)` as `Bool`,
52/// not `TinyInt`.
53///
54/// ### [`ToSql`](crate::serialize::ToSql) impls
55///
56/// - [`i8`][i8]
57///
58/// ### [`FromSql`](crate::deserialize::FromSql) impls
59///
60/// - [`i8`][i8]
61///
62/// [i8]: https://doc.rust-lang.org/nightly/std/primitive.i8.html
63#[derive(#[automatically_derived]
impl ::core::fmt::Debug for TinyInt {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "TinyInt")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for TinyInt {
    #[inline]
    fn clone(&self) -> TinyInt { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for TinyInt { }Copy, #[automatically_derived]
impl ::core::default::Default for TinyInt {
    #[inline]
    fn default() -> TinyInt { TinyInt {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for TinyInt {
            type QueryId = TinyInt<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for TinyInt {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for TinyInt {}
        impl diesel::sql_types::HasSqlType<TinyInt> for diesel::mysql::Mysql {
            fn metadata(_: &mut ()) -> diesel::mysql::MysqlType {
                diesel::mysql::MysqlType::Tiny
            }
        }
        impl diesel::sql_types::HasSqlType<TinyInt> for
            diesel::mariadb::Mariadb {
            fn metadata(_: &mut ()) -> diesel::mariadb::MariadbType {
                diesel::mariadb::MariadbType::Tiny
            }
        }
    };SqlType)]
64#[diesel(mysql_type(name = "Tiny"))]
65#[diesel(mariadb_type(name = "Tiny"))]
66pub struct TinyInt;
67#[doc(hidden)]
68pub type Tinyint = TinyInt;
69
70/// The small integer SQL type.
71///
72/// ### [`ToSql`](crate::serialize::ToSql) impls
73///
74/// - [`i16`][i16]
75///
76/// ### [`FromSql`](crate::deserialize::FromSql) impls
77///
78/// - [`i16`][i16]
79///
80/// [i16]: https://doc.rust-lang.org/nightly/std/primitive.i16.html
81#[derive(#[automatically_derived]
impl ::core::fmt::Debug for SmallInt {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "SmallInt")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for SmallInt {
    #[inline]
    fn clone(&self) -> SmallInt { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for SmallInt { }Copy, #[automatically_derived]
impl ::core::default::Default for SmallInt {
    #[inline]
    fn default() -> SmallInt { SmallInt {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for SmallInt {
            type QueryId = SmallInt<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for SmallInt {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for SmallInt {}
        impl diesel::sql_types::HasSqlType<SmallInt> for
            diesel::sqlite::Sqlite {
            fn metadata(_: &mut ()) -> diesel::sqlite::SqliteType {
                diesel::sqlite::SqliteType::SmallInt
            }
        }
        impl diesel::sql_types::HasSqlType<SmallInt> for diesel::mysql::Mysql
            {
            fn metadata(_: &mut ()) -> diesel::mysql::MysqlType {
                diesel::mysql::MysqlType::Short
            }
        }
        impl diesel::sql_types::HasSqlType<SmallInt> for
            diesel::mariadb::Mariadb {
            fn metadata(_: &mut ()) -> diesel::mariadb::MariadbType {
                diesel::mariadb::MariadbType::Short
            }
        }
        impl diesel::sql_types::HasSqlType<SmallInt> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup)
                -> diesel::pg::PgTypeMetadata {
                diesel::pg::PgTypeMetadata::new(21, 1005)
            }
        }
    };SqlType)]
82#[diesel(postgres_type(oid = 21, array_oid = 1005))]
83#[diesel(sqlite_type(name = "SmallInt"))]
84#[diesel(mysql_type(name = "Short"))]
85#[diesel(mariadb_type(name = "Short"))]
86pub struct SmallInt;
87#[doc(hidden)]
88pub type Int2 = SmallInt;
89#[doc(hidden)]
90pub type Smallint = SmallInt;
91
92/// The integer SQL type.
93///
94/// ### [`ToSql`](crate::serialize::ToSql) impls
95///
96/// - [`i32`][i32]
97///
98/// ### [`FromSql`](crate::deserialize::FromSql) impls
99///
100/// - [`i32`][i32]
101///
102/// [i32]: https://doc.rust-lang.org/nightly/std/primitive.i32.html
103#[derive(#[automatically_derived]
impl ::core::fmt::Debug for Integer {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Integer")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Integer {
    #[inline]
    fn clone(&self) -> Integer { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Integer { }Copy, #[automatically_derived]
impl ::core::default::Default for Integer {
    #[inline]
    fn default() -> Integer { Integer {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Integer {
            type QueryId = Integer<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Integer {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Integer {}
        impl diesel::sql_types::HasSqlType<Integer> for diesel::sqlite::Sqlite
            {
            fn metadata(_: &mut ()) -> diesel::sqlite::SqliteType {
                diesel::sqlite::SqliteType::Integer
            }
        }
        impl diesel::sql_types::HasSqlType<Integer> for diesel::mysql::Mysql {
            fn metadata(_: &mut ()) -> diesel::mysql::MysqlType {
                diesel::mysql::MysqlType::Long
            }
        }
        impl diesel::sql_types::HasSqlType<Integer> for
            diesel::mariadb::Mariadb {
            fn metadata(_: &mut ()) -> diesel::mariadb::MariadbType {
                diesel::mariadb::MariadbType::Long
            }
        }
        impl diesel::sql_types::HasSqlType<Integer> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup)
                -> diesel::pg::PgTypeMetadata {
                diesel::pg::PgTypeMetadata::new(23, 1007)
            }
        }
    };SqlType)]
104#[diesel(postgres_type(oid = 23, array_oid = 1007))]
105#[diesel(sqlite_type(name = "Integer"))]
106#[diesel(mysql_type(name = "Long"))]
107#[diesel(mariadb_type(name = "Long"))]
108pub struct Integer;
109#[doc(hidden)]
110pub type Int4 = Integer;
111
112/// The big integer SQL type.
113///
114/// ### [`ToSql`](crate::serialize::ToSql) impls
115///
116/// - [`i64`][i64]
117///
118/// ### [`FromSql`](crate::deserialize::FromSql) impls
119///
120/// - [`i64`][i64]
121///
122/// [i64]: https://doc.rust-lang.org/nightly/std/primitive.i64.html
123#[derive(#[automatically_derived]
impl ::core::fmt::Debug for BigInt {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "BigInt")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for BigInt {
    #[inline]
    fn clone(&self) -> BigInt { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for BigInt { }Copy, #[automatically_derived]
impl ::core::default::Default for BigInt {
    #[inline]
    fn default() -> BigInt { BigInt {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for BigInt {
            type QueryId = BigInt<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for BigInt {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for BigInt {}
        impl diesel::sql_types::HasSqlType<BigInt> for diesel::sqlite::Sqlite
            {
            fn metadata(_: &mut ()) -> diesel::sqlite::SqliteType {
                diesel::sqlite::SqliteType::Long
            }
        }
        impl diesel::sql_types::HasSqlType<BigInt> for diesel::mysql::Mysql {
            fn metadata(_: &mut ()) -> diesel::mysql::MysqlType {
                diesel::mysql::MysqlType::LongLong
            }
        }
        impl diesel::sql_types::HasSqlType<BigInt> for
            diesel::mariadb::Mariadb {
            fn metadata(_: &mut ()) -> diesel::mariadb::MariadbType {
                diesel::mariadb::MariadbType::LongLong
            }
        }
        impl diesel::sql_types::HasSqlType<BigInt> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup)
                -> diesel::pg::PgTypeMetadata {
                diesel::pg::PgTypeMetadata::new(20, 1016)
            }
        }
    };SqlType)]
124#[diesel(postgres_type(oid = 20, array_oid = 1016))]
125#[diesel(sqlite_type(name = "Long"))]
126#[diesel(mysql_type(name = "LongLong"))]
127#[diesel(mariadb_type(name = "LongLong"))]
128pub struct BigInt;
129#[doc(hidden)]
130pub type Int8 = BigInt;
131#[doc(hidden)]
132pub type Bigint = BigInt;
133
134/// The float SQL type.
135///
136/// ### [`ToSql`](crate::serialize::ToSql) impls
137///
138/// - [`f32`][f32]
139///
140/// ### [`FromSql`](crate::deserialize::FromSql) impls
141///
142/// - [`f32`][f32]
143///
144/// [f32]: https://doc.rust-lang.org/nightly/std/primitive.f32.html
145#[derive(#[automatically_derived]
impl ::core::fmt::Debug for Float {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Float")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Float {
    #[inline]
    fn clone(&self) -> Float { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Float { }Copy, #[automatically_derived]
impl ::core::default::Default for Float {
    #[inline]
    fn default() -> Float { Float {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Float {
            type QueryId = Float<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Float {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Float {}
        impl diesel::sql_types::HasSqlType<Float> for diesel::sqlite::Sqlite {
            fn metadata(_: &mut ()) -> diesel::sqlite::SqliteType {
                diesel::sqlite::SqliteType::Float
            }
        }
        impl diesel::sql_types::HasSqlType<Float> for diesel::mysql::Mysql {
            fn metadata(_: &mut ()) -> diesel::mysql::MysqlType {
                diesel::mysql::MysqlType::Float
            }
        }
        impl diesel::sql_types::HasSqlType<Float> for diesel::mariadb::Mariadb
            {
            fn metadata(_: &mut ()) -> diesel::mariadb::MariadbType {
                diesel::mariadb::MariadbType::Float
            }
        }
        impl diesel::sql_types::HasSqlType<Float> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup)
                -> diesel::pg::PgTypeMetadata {
                diesel::pg::PgTypeMetadata::new(700, 1021)
            }
        }
    };SqlType)]
146#[diesel(postgres_type(oid = 700, array_oid = 1021))]
147#[diesel(sqlite_type(name = "Float"))]
148#[diesel(mysql_type(name = "Float"))]
149#[diesel(mariadb_type(name = "Float"))]
150pub struct Float;
151#[doc(hidden)]
152pub type Float4 = Float;
153
154/// The double precision float SQL type.
155///
156/// ### [`ToSql`](crate::serialize::ToSql) impls
157///
158/// - [`f64`][f64]
159///
160/// ### [`FromSql`](crate::deserialize::FromSql) impls
161///
162/// - [`f64`][f64]
163///
164/// [f64]: https://doc.rust-lang.org/nightly/std/primitive.f64.html
165#[derive(#[automatically_derived]
impl ::core::fmt::Debug for Double {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Double")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Double {
    #[inline]
    fn clone(&self) -> Double { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Double { }Copy, #[automatically_derived]
impl ::core::default::Default for Double {
    #[inline]
    fn default() -> Double { Double {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Double {
            type QueryId = Double<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Double {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Double {}
        impl diesel::sql_types::HasSqlType<Double> for diesel::sqlite::Sqlite
            {
            fn metadata(_: &mut ()) -> diesel::sqlite::SqliteType {
                diesel::sqlite::SqliteType::Double
            }
        }
        impl diesel::sql_types::HasSqlType<Double> for diesel::mysql::Mysql {
            fn metadata(_: &mut ()) -> diesel::mysql::MysqlType {
                diesel::mysql::MysqlType::Double
            }
        }
        impl diesel::sql_types::HasSqlType<Double> for
            diesel::mariadb::Mariadb {
            fn metadata(_: &mut ()) -> diesel::mariadb::MariadbType {
                diesel::mariadb::MariadbType::Double
            }
        }
        impl diesel::sql_types::HasSqlType<Double> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup)
                -> diesel::pg::PgTypeMetadata {
                diesel::pg::PgTypeMetadata::new(701, 1022)
            }
        }
    };SqlType)]
166#[diesel(postgres_type(oid = 701, array_oid = 1022))]
167#[diesel(sqlite_type(name = "Double"))]
168#[diesel(mysql_type(name = "Double"))]
169#[diesel(mariadb_type(name = "Double"))]
170pub struct Double;
171#[doc(hidden)]
172pub type Float8 = Double;
173
174/// The arbitrary precision numeric SQL type.
175///
176/// This type is only supported on PostgreSQL and MySQL.
177/// On SQLite, [`Double`] should be used instead.
178///
179/// ### [`ToSql`](crate::serialize::ToSql) impls
180///
181/// - [`bigdecimal::BigDecimal`] with `feature = ["numeric"]`
182///
183/// ### [`FromSql`](crate::deserialize::FromSql) impls
184///
185/// - [`bigdecimal::BigDecimal`] with `feature = ["numeric"]`
186///
187/// [`bigdecimal::BigDecimal`]: /bigdecimal/struct.BigDecimal.html
188#[derive(#[automatically_derived]
impl ::core::fmt::Debug for Numeric {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Numeric")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Numeric {
    #[inline]
    fn clone(&self) -> Numeric { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Numeric { }Copy, #[automatically_derived]
impl ::core::default::Default for Numeric {
    #[inline]
    fn default() -> Numeric { Numeric {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Numeric {
            type QueryId = Numeric<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Numeric {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Numeric {}
        impl diesel::sql_types::HasSqlType<Numeric> for diesel::sqlite::Sqlite
            {
            fn metadata(_: &mut ()) -> diesel::sqlite::SqliteType {
                diesel::sqlite::SqliteType::Double
            }
        }
        impl diesel::sql_types::HasSqlType<Numeric> for diesel::mysql::Mysql {
            fn metadata(_: &mut ()) -> diesel::mysql::MysqlType {
                diesel::mysql::MysqlType::Numeric
            }
        }
        impl diesel::sql_types::HasSqlType<Numeric> for
            diesel::mariadb::Mariadb {
            fn metadata(_: &mut ()) -> diesel::mariadb::MariadbType {
                diesel::mariadb::MariadbType::Numeric
            }
        }
        impl diesel::sql_types::HasSqlType<Numeric> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup)
                -> diesel::pg::PgTypeMetadata {
                diesel::pg::PgTypeMetadata::new(1700, 1231)
            }
        }
    };SqlType)]
189#[diesel(postgres_type(oid = 1700, array_oid = 1231))]
190#[diesel(mysql_type(name = "Numeric"))]
191#[diesel(mariadb_type(name = "Numeric"))]
192#[diesel(sqlite_type(name = "Double"))]
193pub struct Numeric;
194
195/// Alias for `Numeric`
196pub type Decimal = Numeric;
197
198/// The text SQL type.
199///
200/// On all backends strings must be valid UTF-8.
201/// On PostgreSQL strings must not include nul bytes.
202///
203/// Schema inference will treat all variants of `TEXT` as this type (e.g.
204/// `VARCHAR`, `MEDIUMTEXT`, etc).
205///
206/// ### [`ToSql`](crate::serialize::ToSql) impls
207///
208/// - [`String`]
209/// - [`&str`][str]
210///
211/// ### [`FromSql`](crate::deserialize::FromSql) impls
212///
213/// - [`String`]
214///
215/// [str]: https://doc.rust-lang.org/nightly/std/primitive.str.html
216#[derive(#[automatically_derived]
impl ::core::fmt::Debug for Text {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Text")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Text {
    #[inline]
    fn clone(&self) -> Text { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Text { }Copy, #[automatically_derived]
impl ::core::default::Default for Text {
    #[inline]
    fn default() -> Text { Text {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Text {
            type QueryId = Text<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Text {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Text {}
        impl diesel::sql_types::HasSqlType<Text> for diesel::sqlite::Sqlite {
            fn metadata(_: &mut ()) -> diesel::sqlite::SqliteType {
                diesel::sqlite::SqliteType::Text
            }
        }
        impl diesel::sql_types::HasSqlType<Text> for diesel::mysql::Mysql {
            fn metadata(_: &mut ()) -> diesel::mysql::MysqlType {
                diesel::mysql::MysqlType::String
            }
        }
        impl diesel::sql_types::HasSqlType<Text> for diesel::mariadb::Mariadb
            {
            fn metadata(_: &mut ()) -> diesel::mariadb::MariadbType {
                diesel::mariadb::MariadbType::String
            }
        }
        impl diesel::sql_types::HasSqlType<Text> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup)
                -> diesel::pg::PgTypeMetadata {
                diesel::pg::PgTypeMetadata::new(25, 1009)
            }
        }
    };SqlType)]
217#[diesel(postgres_type(oid = 25, array_oid = 1009))]
218#[diesel(sqlite_type(name = "Text"))]
219#[diesel(mysql_type(name = "String"))]
220#[diesel(mariadb_type(name = "String"))]
221pub struct Text;
222
223/// The SQL `VARCHAR` type
224///
225/// This type is generally interchangeable with `TEXT`, so Diesel has this as an
226/// alias rather than a separate type (Diesel does not currently support
227/// implicit coercions).
228///
229/// One notable exception to this is with arrays on PG. `TEXT[]` cannot be
230/// coerced to `VARCHAR[]`.  It is recommended that you always use `TEXT[]` if
231/// you need a string array on PG.
232pub type VarChar = Text;
233#[doc(hidden)]
234pub type Varchar = VarChar;
235#[doc(hidden)]
236pub type Char = Text;
237#[doc(hidden)]
238pub type Tinytext = Text;
239#[doc(hidden)]
240pub type Mediumtext = Text;
241#[doc(hidden)]
242pub type Longtext = Text;
243
244/// The binary SQL type.
245///
246/// Schema inference will treat all variants of `BLOB` as this type (e.g.
247/// `VARBINARY`, `MEDIUMBLOB`, etc).
248///
249/// ### [`ToSql`](crate::serialize::ToSql) impls
250///
251/// - [`Vec<u8>`][Vec]
252/// - [`&[u8]`][slice]
253///
254/// ### [`FromSql`](crate::deserialize::FromSql) impls
255///
256/// - [`Vec<u8>`][Vec]
257///
258/// [Vec]: std::vec::Vec
259/// [slice]: https://doc.rust-lang.org/nightly/std/primitive.slice.html
260#[derive(#[automatically_derived]
impl ::core::fmt::Debug for Binary {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Binary")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Binary {
    #[inline]
    fn clone(&self) -> Binary { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Binary { }Copy, #[automatically_derived]
impl ::core::default::Default for Binary {
    #[inline]
    fn default() -> Binary { Binary {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Binary {
            type QueryId = Binary<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Binary {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Binary {}
        impl diesel::sql_types::HasSqlType<Binary> for diesel::sqlite::Sqlite
            {
            fn metadata(_: &mut ()) -> diesel::sqlite::SqliteType {
                diesel::sqlite::SqliteType::Binary
            }
        }
        impl diesel::sql_types::HasSqlType<Binary> for diesel::mysql::Mysql {
            fn metadata(_: &mut ()) -> diesel::mysql::MysqlType {
                diesel::mysql::MysqlType::Blob
            }
        }
        impl diesel::sql_types::HasSqlType<Binary> for
            diesel::mariadb::Mariadb {
            fn metadata(_: &mut ()) -> diesel::mariadb::MariadbType {
                diesel::mariadb::MariadbType::Blob
            }
        }
        impl diesel::sql_types::HasSqlType<Binary> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup)
                -> diesel::pg::PgTypeMetadata {
                diesel::pg::PgTypeMetadata::new(17, 1001)
            }
        }
    };SqlType)]
261#[diesel(postgres_type(oid = 17, array_oid = 1001))]
262#[diesel(sqlite_type(name = "Binary"))]
263#[diesel(mysql_type(name = "Blob"))]
264#[diesel(mariadb_type(name = "Blob"))]
265pub struct Binary;
266
267#[doc(hidden)]
268pub type Tinyblob = Binary;
269#[doc(hidden)]
270pub type Blob = Binary;
271#[doc(hidden)]
272pub type Mediumblob = Binary;
273#[doc(hidden)]
274pub type Longblob = Binary;
275#[doc(hidden)]
276pub type Varbinary = Binary;
277#[doc(hidden)]
278pub type Bit = Binary;
279
280/// The date SQL type.
281///
282/// ### [`ToSql`](crate::serialize::ToSql) impls
283///
284/// - [`chrono::NaiveDate`][NaiveDate] with `feature = "chrono"`
285/// - [`time::Date`][Date] with `feature = "time"`
286///
287/// ### [`FromSql`](crate::deserialize::FromSql) impls
288///
289/// - [`chrono::NaiveDate`][NaiveDate] with `feature = "chrono"`
290/// - [`time::Date`][Date] with `feature = "time"`
291///
292/// [NaiveDate]: https://docs.rs/chrono/*/chrono/naive/struct.NaiveDate.html
293/// [Date]: https://docs.rs/time/0.3.9/time/struct.Date.html
294#[derive(#[automatically_derived]
impl ::core::fmt::Debug for Date {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Date")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Date {
    #[inline]
    fn clone(&self) -> Date { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Date { }Copy, #[automatically_derived]
impl ::core::default::Default for Date {
    #[inline]
    fn default() -> Date { Date {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Date {
            type QueryId = Date<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Date {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Date {}
        impl diesel::sql_types::HasSqlType<Date> for diesel::sqlite::Sqlite {
            fn metadata(_: &mut ()) -> diesel::sqlite::SqliteType {
                diesel::sqlite::SqliteType::Text
            }
        }
        impl diesel::sql_types::HasSqlType<Date> for diesel::mysql::Mysql {
            fn metadata(_: &mut ()) -> diesel::mysql::MysqlType {
                diesel::mysql::MysqlType::Date
            }
        }
        impl diesel::sql_types::HasSqlType<Date> for diesel::mariadb::Mariadb
            {
            fn metadata(_: &mut ()) -> diesel::mariadb::MariadbType {
                diesel::mariadb::MariadbType::Date
            }
        }
        impl diesel::sql_types::HasSqlType<Date> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup)
                -> diesel::pg::PgTypeMetadata {
                diesel::pg::PgTypeMetadata::new(1082, 1182)
            }
        }
    };SqlType)]
295#[diesel(postgres_type(oid = 1082, array_oid = 1182))]
296#[diesel(sqlite_type(name = "Text"))]
297#[diesel(mysql_type(name = "Date"))]
298#[diesel(mariadb_type(name = "Date"))]
299pub struct Date;
300
301/// The interval SQL type.
302///
303/// This type is currently only implemented for PostgreSQL.
304///
305/// ### [`ToSql`](crate::serialize::ToSql) impls
306///
307/// - [`PgInterval`] which can be constructed using [`IntervalDsl`]
308/// - [`chrono::Duration`][Duration] with `feature = "chrono"`
309///
310/// ### [`FromSql`](crate::deserialize::FromSql) impls
311///
312/// - [`PgInterval`] which can be constructed using [`IntervalDsl`]
313/// - [`chrono::Duration`][Duration] with `feature = "chrono"`
314///   (There might be some information loss due to special behavior for literal `month` (or longer) intervals;
315///   Please read official documentation of [PostgreSQL Interval].)
316///
317/// [`PgInterval`]: ../pg/data_types/struct.PgInterval.html
318/// [`IntervalDsl`]: ../pg/expression/extensions/trait.IntervalDsl.html
319/// [Duration]: https://docs.rs/chrono/*/chrono/type.Duration.html
320/// [PostgreSQL Interval]: https://www.postgresql.org/docs/current/datatype-datetime.html#DATATYPE-INTERVAL-INPUT
321#[derive(#[automatically_derived]
impl ::core::fmt::Debug for Interval {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Interval")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Interval {
    #[inline]
    fn clone(&self) -> Interval { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Interval { }Copy, #[automatically_derived]
impl ::core::default::Default for Interval {
    #[inline]
    fn default() -> Interval { Interval {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Interval {
            type QueryId = Interval<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Interval {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Interval {}
        impl diesel::sql_types::HasSqlType<Interval> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup)
                -> diesel::pg::PgTypeMetadata {
                diesel::pg::PgTypeMetadata::new(1186, 1187)
            }
        }
    };SqlType)]
322#[diesel(postgres_type(oid = 1186, array_oid = 1187))]
323pub struct Interval;
324
325/// The time SQL type.
326///
327/// ### [`ToSql`](crate::serialize::ToSql) impls
328///
329/// - [`chrono::NaiveTime`][NaiveTime] with `feature = "chrono"`
330/// - [`time::Time`][Time] with `feature = "time"`
331///
332/// ### [`FromSql`](crate::deserialize::FromSql) impls
333///
334/// - [`chrono::NaiveTime`][NaiveTime] with `feature = "chrono"`
335/// - [`time::Time`][Time] with `feature = "time"`
336///
337/// [NaiveTime]: /chrono/naive/time/struct.NaiveTime.html
338/// [Time]: /time/struct.Time.html
339#[derive(#[automatically_derived]
impl ::core::fmt::Debug for Time {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Time")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Time {
    #[inline]
    fn clone(&self) -> Time { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Time { }Copy, #[automatically_derived]
impl ::core::default::Default for Time {
    #[inline]
    fn default() -> Time { Time {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Time {
            type QueryId = Time<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Time {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Time {}
        impl diesel::sql_types::HasSqlType<Time> for diesel::sqlite::Sqlite {
            fn metadata(_: &mut ()) -> diesel::sqlite::SqliteType {
                diesel::sqlite::SqliteType::Text
            }
        }
        impl diesel::sql_types::HasSqlType<Time> for diesel::mysql::Mysql {
            fn metadata(_: &mut ()) -> diesel::mysql::MysqlType {
                diesel::mysql::MysqlType::Time
            }
        }
        impl diesel::sql_types::HasSqlType<Time> for diesel::mariadb::Mariadb
            {
            fn metadata(_: &mut ()) -> diesel::mariadb::MariadbType {
                diesel::mariadb::MariadbType::Time
            }
        }
        impl diesel::sql_types::HasSqlType<Time> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup)
                -> diesel::pg::PgTypeMetadata {
                diesel::pg::PgTypeMetadata::new(1083, 1183)
            }
        }
    };SqlType)]
340#[diesel(postgres_type(oid = 1083, array_oid = 1183))]
341#[diesel(sqlite_type(name = "Text"))]
342#[diesel(mysql_type(name = "Time"))]
343#[diesel(mariadb_type(name = "Time"))]
344pub struct Time;
345
346#[allow(rustdoc::redundant_explicit_links)]
347/// The timestamp SQL type.
348///
349/// ### [`ToSql`](crate::serialize::ToSql) impls
350///
351/// - [`std::time::SystemTime`][SystemTime] (PG only)
352/// - [`chrono::NaiveDateTime`][NaiveDateTime] with `feature = "chrono"`
353/// - [`time::PrimitiveDateTime`] with `feature = "time"`
354/// - [`time::OffsetDateTime`] with `feature = "time"` (MySQL only)
355///
356/// ### [`FromSql`](crate::deserialize::FromSql) impls
357///
358/// - [`std::time::SystemTime`][SystemTime] (PG only)
359/// - [`chrono::NaiveDateTime`][NaiveDateTime] with `feature = "chrono"`
360/// - [`time::PrimitiveDateTime`] with `feature = "time"`
361/// - [`time::OffsetDateTime`] with `feature = "time"` (MySQL only)
362///
363/// [SystemTime]: std::time::SystemTime
364#[cfg_attr(
365    feature = "chrono",
366    doc = " [NaiveDateTime]: chrono::naive::NaiveDateTime"
367)]
368#[cfg_attr(
369    not(feature = "chrono"),
370    doc = " [NaiveDateTime]: https://docs.rs/chrono/*/chrono/naive/struct.NaiveDateTime.html"
371)]
372#[cfg_attr(
373    feature = "time",
374    doc = " [`time::PrimitiveDateTime`]: time::PrimitiveDateTime"
375)]
376#[cfg_attr(
377    not(feature = "time"),
378    doc = " [`time::PrimitiveDateTime`]: https://docs.rs/time/0.3.9/time/struct.PrimitiveDateTime.html"
379)]
380#[cfg_attr(
381    feature = "time",
382    doc = " [`time::OffsetDateTime`]: time::OffsetDateTime"
383)]
384#[cfg_attr(
385    not(feature = "time"),
386    doc = " [`time::OffsetDateTime`]: https://docs.rs/time/0.3.9/time/struct.OffsetDateTime.html"
387)]
388/// [Timespec]: /time/struct.Timespec.html
389#[derive(#[automatically_derived]
#[allow(rustdoc::redundant_explicit_links)]
impl ::core::fmt::Debug for Timestamp {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Timestamp")
    }
}Debug, #[automatically_derived]
#[allow(rustdoc::redundant_explicit_links)]
impl ::core::clone::Clone for Timestamp {
    #[inline]
    fn clone(&self) -> Timestamp { *self }
}Clone, #[automatically_derived]
#[allow(rustdoc::redundant_explicit_links)]
impl ::core::marker::Copy for Timestamp { }Copy, #[automatically_derived]
#[allow(rustdoc::redundant_explicit_links)]
impl ::core::default::Default for Timestamp {
    #[inline]
    fn default() -> Timestamp { Timestamp {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Timestamp {
            type QueryId = Timestamp<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Timestamp {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Timestamp {}
        impl diesel::sql_types::HasSqlType<Timestamp> for
            diesel::sqlite::Sqlite {
            fn metadata(_: &mut ()) -> diesel::sqlite::SqliteType {
                diesel::sqlite::SqliteType::Text
            }
        }
        impl diesel::sql_types::HasSqlType<Timestamp> for diesel::mysql::Mysql
            {
            fn metadata(_: &mut ()) -> diesel::mysql::MysqlType {
                diesel::mysql::MysqlType::Timestamp
            }
        }
        impl diesel::sql_types::HasSqlType<Timestamp> for
            diesel::mariadb::Mariadb {
            fn metadata(_: &mut ()) -> diesel::mariadb::MariadbType {
                diesel::mariadb::MariadbType::Timestamp
            }
        }
        impl diesel::sql_types::HasSqlType<Timestamp> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup)
                -> diesel::pg::PgTypeMetadata {
                diesel::pg::PgTypeMetadata::new(1114, 1115)
            }
        }
    };SqlType)]
390#[diesel(postgres_type(oid = 1114, array_oid = 1115))]
391#[diesel(sqlite_type(name = "Text"))]
392#[diesel(mysql_type(name = "Timestamp"))]
393#[diesel(mariadb_type(name = "Timestamp"))]
394pub struct Timestamp;
395
396/// The JSON SQL type.  This type can only be used with `feature =
397/// "serde_json"`
398///
399/// For postgresql you should normally prefer [`Jsonb`](struct.Jsonb.html) instead,
400/// for the reasons discussed there.
401///
402/// ### [`ToSql`] impls
403///
404/// - [`serde_json::Value`]
405///
406/// ### [`FromSql`] impls
407///
408/// - [`serde_json::Value`]
409///
410/// [`ToSql`]: /serialize/trait.ToSql.html
411/// [`FromSql`]: /deserialize/trait.FromSql.html
412/// [`serde_json::Value`]: /../serde_json/value/enum.Value.html
413#[derive(#[automatically_derived]
impl ::core::fmt::Debug for Json {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Json")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Json {
    #[inline]
    fn clone(&self) -> Json { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Json { }Copy, #[automatically_derived]
impl ::core::default::Default for Json {
    #[inline]
    fn default() -> Json { Json {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Json {
            type QueryId = Json<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Json {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Json {}
        impl diesel::sql_types::HasSqlType<Json> for diesel::sqlite::Sqlite {
            fn metadata(_: &mut ()) -> diesel::sqlite::SqliteType {
                diesel::sqlite::SqliteType::Text
            }
        }
        impl diesel::sql_types::HasSqlType<Json> for diesel::mysql::Mysql {
            fn metadata(_: &mut ()) -> diesel::mysql::MysqlType {
                diesel::mysql::MysqlType::String
            }
        }
        impl diesel::sql_types::HasSqlType<Json> for diesel::mariadb::Mariadb
            {
            fn metadata(_: &mut ()) -> diesel::mariadb::MariadbType {
                diesel::mariadb::MariadbType::String
            }
        }
        impl diesel::sql_types::HasSqlType<Json> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup)
                -> diesel::pg::PgTypeMetadata {
                diesel::pg::PgTypeMetadata::new(114, 199)
            }
        }
    };SqlType)]
414#[diesel(postgres_type(oid = 114, array_oid = 199))]
415#[diesel(mysql_type(name = "String"))]
416#[diesel(mariadb_type(name = "String"))]
417#[diesel(sqlite_type(name = "Text"))]
418pub struct Json;
419
420/// The [`jsonb`] SQL type.  This type can only be used with `feature =
421/// "serde_json"`
422///
423/// In SQLite, `jsonb` brings mainly [performance improvements][sqlite-adv] over
424/// regular JSON:
425///
426/// > The advantage of JSONB in SQLite is that it is smaller and faster than
427/// > text JSON - potentially several times faster. There is space in the
428/// > on-disk JSONB format to add enhancements and future versions of SQLite
429/// > might include options to provide O(1) lookup of elements in JSONB, but no
430/// > such capability is currently available.
431///
432/// <div class="warning">
433/// In SQLite, JSONB is intended for internal use by SQLite only. Thus, future
434/// SQLite updates might break our JSONB implementation. And one might have to
435/// wait and then upgrade <code>diesel</code> for those changes to be  accounted
436/// for. If you do not want this, prefer the regular
437/// <a href="./struct.Json.html"><code>Json</code></a> type.
438/// </div>
439///
440/// In PostgreSQL, `jsonb` offers [several advantages][pg-adv] over regular JSON:
441///
442/// > There are two JSON data types: `json` and `jsonb`. They accept almost
443/// > identical sets of values as input. The major practical difference
444/// > is one of efficiency. The `json` data type stores an exact copy of
445/// > the input text, which processing functions must reparse on each
446/// > execution; while `jsonb` data is stored in a decomposed binary format
447/// > that makes it slightly slower to input due to added conversion
448/// > overhead, but significantly faster to process, since no reparsing
449/// > is needed. `jsonb` also supports indexing, which can be a significant
450/// > advantage.
451/// >
452/// > ...In general, most applications should prefer to store JSON data as
453/// > `jsonb`, unless there are quite specialized needs, such as legacy
454/// > assumptions about ordering of object keys.
455///
456/// [pg-adv]: https://www.postgresql.org/docs/current/static/datatype-json.html
457/// [sqlite-adv]: https://sqlite.org/draft/jsonb.html
458///
459/// ### [`ToSql`] impls
460///
461/// - [`serde_json::Value`]
462///
463/// ### [`FromSql`] impls
464///
465/// - [`serde_json::Value`]
466///
467/// [`ToSql`]: crate::serialize::ToSql
468/// [`FromSql`]: crate::deserialize::FromSql
469/// [`jsonb`]: https://www.postgresql.org/docs/current/datatype-json.html
470#[cfg_attr(
471    feature = "serde_json",
472    doc = "[`serde_json::Value`]: serde_json::value::Value"
473)]
474#[cfg_attr(
475    not(feature = "serde_json"),
476    doc = "[`serde_json::Value`]: https://docs.rs/serde_json/1.0.64/serde_json/value/enum.Value.html"
477)]
478///
479/// ## Examples
480///
481/// ```rust
482/// # #![allow(dead_code)]
483/// # include!("../doctest_setup.rs");
484/// #
485/// table! {
486///     contacts {
487///         id -> Integer,
488///         name -> Text,
489///         address -> Jsonb,
490///     }
491/// }
492///
493/// # #[cfg(all(
494/// #   feature = "serde_json",
495/// #   any(
496/// #       feature = "postgres_backend",
497/// #       feature = "returning_clauses_for_sqlite_3_35",
498/// #   )
499/// # ))]
500/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
501/// #     use diesel::insert_into;
502/// #     use self::contacts::dsl::*;
503/// #     let connection = &mut connection_no_data();
504/// # #[cfg(feature = "postgres_backend")]
505/// #     diesel::sql_query("CREATE TABLE contacts (
506/// #         id SERIAL PRIMARY KEY,
507/// #         name VARCHAR NOT NULL,
508/// #         address JSONB NOT NULL
509/// #     )").execute(connection)?;
510/// # #[cfg(feature = "__sqlite-shared")]
511/// #     diesel::sql_query("CREATE TABLE contacts (
512/// #         id INT PRIMARY KEY,
513/// #         name TEXT NOT NULL,
514/// #         address BLOB NOT NULL
515/// #     )").execute(connection)?;
516/// let santas_address: serde_json::Value = serde_json::from_str(
517///     r#"{
518///     "street": "Article Circle Expressway 1",
519///     "city": "North Pole",
520///     "postcode": "99705",
521///     "state": "Alaska"
522/// }"#,
523/// )?;
524/// let inserted_address = insert_into(contacts)
525///     .values((name.eq("Claus"), address.eq(&santas_address)))
526///     .returning(address)
527///     .get_result::<serde_json::Value>(connection)?;
528/// assert_eq!(santas_address, inserted_address);
529/// #     Ok(())
530/// # }
531/// # #[cfg(not(all(
532/// #   feature = "serde_json",
533/// #   any(
534/// #       feature = "postgres_backend",
535/// #       feature = "returning_clauses_for_sqlite_3_35",
536/// #   )
537/// # )))]
538/// # fn main() {}
539/// ```
540#[derive(#[automatically_derived]
impl ::core::fmt::Debug for Jsonb {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "Jsonb")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Jsonb {
    #[inline]
    fn clone(&self) -> Jsonb { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for Jsonb { }Copy, #[automatically_derived]
impl ::core::default::Default for Jsonb {
    #[inline]
    fn default() -> Jsonb { Jsonb {} }
}Default, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl diesel::query_builder::QueryId for Jsonb {
            type QueryId = Jsonb<>;
            const HAS_STATIC_QUERY_ID: bool = true;
            const IS_WINDOW_FUNCTION: bool = false;
        }
    };QueryId, const _: () =
    {
        use diesel;
        impl diesel::sql_types::SqlType for Jsonb {
            type IsNull = diesel::sql_types::is_nullable::NotNull;
            const IS_ARRAY: bool = false;
        }
        impl diesel::sql_types::SingleValue for Jsonb {}
        impl diesel::sql_types::HasSqlType<Jsonb> for diesel::sqlite::Sqlite {
            fn metadata(_: &mut ()) -> diesel::sqlite::SqliteType {
                diesel::sqlite::SqliteType::Binary
            }
        }
        impl diesel::sql_types::HasSqlType<Jsonb> for diesel::pg::Pg {
            fn metadata(_: &mut Self::MetadataLookup)
                -> diesel::pg::PgTypeMetadata {
                diesel::pg::PgTypeMetadata::new(3802, 3807)
            }
        }
    };SqlType)]
541#[diesel(postgres_type(oid = 3802, array_oid = 3807))]
542#[diesel(sqlite_type(name = "Binary"))]
543pub struct Jsonb;
544
545/// The nullable SQL type.
546///
547/// This wraps another SQL type to indicate that it can be null.
548/// By default all values are assumed to be `NOT NULL`.
549///
550/// ### [`ToSql`](crate::serialize::ToSql) impls
551///
552/// - Any `T` which implements `ToSql<ST>`
553/// - `Option<T>` for any `T` which implements `ToSql<ST>`
554///
555/// ### [`FromSql`](crate::deserialize::FromSql) impls
556///
557/// - `Option<T>` for any `T` which implements `FromSql<ST>`
558#[derive(#[automatically_derived]
impl<ST: ::core::fmt::Debug> ::core::fmt::Debug for Nullable<ST> {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Nullable",
            &&self.0)
    }
}Debug, #[automatically_derived]
impl<ST: ::core::clone::Clone> ::core::clone::Clone for Nullable<ST> {
    #[inline]
    fn clone(&self) -> Nullable<ST> {
        Nullable(::core::clone::Clone::clone(&self.0))
    }
}Clone, #[automatically_derived]
impl<ST: ::core::marker::Copy> ::core::marker::Copy for Nullable<ST> { }Copy, #[automatically_derived]
impl<ST: ::core::default::Default> ::core::default::Default for Nullable<ST> {
    #[inline]
    fn default() -> Nullable<ST> {
        Nullable(::core::default::Default::default())
    }
}Default)]
559pub struct Nullable<ST>(ST);
560
561impl<ST> SqlType for Nullable<ST>
562where
563    ST: SqlType,
564{
565    type IsNull = is_nullable::IsNullable;
566}
567
568#[doc(inline)]
569#[cfg(feature = "postgres_backend")]
570pub use crate::pg::sql_types::*;
571
572#[doc(inline)]
573#[cfg(any(feature = "mysql_backend", feature = "mariadb_backend"))]
574pub use crate::mysql_like::sql_types::{Datetime, Unsigned};
575
576#[doc(inline)]
577#[cfg(feature = "__sqlite-shared")]
578pub use crate::sqlite::sql_types::Timestamptz as TimestamptzSqlite;
579
580/// Indicates that a SQL type exists for a backend.
581///
582/// This trait can be derived using the [`SqlType` derive](derive@SqlType)
583///
584/// # Example
585///
586/// ```rust
587/// #[derive(diesel::sql_types::SqlType)]
588/// #[diesel(postgres_type(oid = 23, array_oid = 1007))]
589/// #[diesel(sqlite_type(name = "Integer"))]
590/// #[diesel(mysql_type(name = "Long"))]
591/// #[diesel(mariadb_type(name = "Long"))]
592/// pub struct Integer;
593/// ```
594pub trait HasSqlType<ST>: TypeMetadata {
595    /// Fetch the metadata for the given type
596    ///
597    /// This method may use `lookup` to do dynamic runtime lookup. Implementors
598    /// of this method should not do dynamic lookup unless absolutely necessary
599    fn metadata(lookup: &mut Self::MetadataLookup) -> Self::TypeMetadata;
600}
601
602/// Information about how a backend stores metadata about given SQL types
603pub trait TypeMetadata {
604    /// The actual type used to represent metadata.
605    ///
606    /// On PostgreSQL, this is the type's OID.
607    /// On MySQL and SQLite, this is an enum representing all storage classes
608    /// they support.
609    type TypeMetadata;
610    /// The type used for runtime lookup of metadata.
611    ///
612    /// For most backends, which don't support user defined types, this will
613    /// be `()`.
614    type MetadataLookup: ?Sized;
615}
616
617/// Converts a type which may or may not be nullable into its nullable
618/// representation.
619pub trait IntoNullable {
620    /// The nullable representation of this type.
621    ///
622    /// For all types except `Nullable`, this will be `Nullable<Self>`.
623    type Nullable;
624}
625
626impl<T> IntoNullable for T
627where
628    T: SqlType<IsNull = is_nullable::NotNull> + SingleValue,
629{
630    type Nullable = Nullable<T>;
631}
632
633impl<T> IntoNullable for Nullable<T>
634where
635    T: SqlType,
636{
637    type Nullable = Self;
638}
639
640/// Converts a type which may or may not be nullable into its not nullable
641/// representation.
642pub trait IntoNotNullable {
643    /// The not nullable representation of this type.
644    ///
645    /// For `Nullable<T>`, this will be `T` otherwise the type itself
646    type NotNullable;
647}
648
649impl<T> IntoNotNullable for T
650where
651    T: SqlType<IsNull = is_nullable::NotNull>,
652{
653    type NotNullable = T;
654}
655
656impl<T> IntoNotNullable for Nullable<T>
657where
658    T: SqlType,
659{
660    type NotNullable = T;
661}
662
663/// A marker trait indicating that a SQL type represents a single value, as
664/// opposed to a list of values.
665///
666/// This trait should generally be implemented for all SQL types with the
667/// exception of Rust tuples. If a column could have this as its type, this
668/// trait should be implemented.
669///
670/// # Deriving
671///
672/// This trait is automatically implemented by [`#[derive(SqlType)]`](derive@SqlType)
673pub trait SingleValue: SqlType {}
674
675impl<T: SqlType + SingleValue> SingleValue for Nullable<T> {}
676
677#[doc(inline)]
678pub use diesel_derives::DieselNumericOps;
679#[doc(inline)]
680pub use diesel_derives::SqlType;
681
682/// A marker trait for SQL types
683///
684/// # Deriving
685///
686/// This trait is automatically implemented by [`#[derive(SqlType)]`](derive@SqlType)
687/// which sets `IsNull` to [`is_nullable::NotNull`]
688pub trait SqlType: 'static {
689    /// Is this type nullable?
690    ///
691    /// This type should always be one of the structs in the ['is_nullable`]
692    /// module. See the documentation of those structs for more details.
693    ///
694    /// ['is_nullable`]: is_nullable
695    type IsNull: OneIsNullable<is_nullable::IsNullable> + OneIsNullable<is_nullable::NotNull>;
696
697    #[doc(hidden)]
698    const IS_ARRAY: bool = false;
699}
700
701/// A marker trait for SQL types representing database side enums
702///
703/// This trait describes how an enum should be mapped to the underlying database storage type
704/// by specifying one of a set of different strategies.
705///
706/// The generic constant `HAS_EXPLICIT_DISCRIMINANT` can be used to enforce that for a given mapping
707/// the user needs to provide explicit discriminant values. The [`#[derive(Enum)]`](crate::types::Enum) macro
708/// will pass the true only if this is the case.
709///
710/// The generic type `DB` represents the database backend for which this mapping is valid
711///
712/// # Deriving
713///
714/// This trait can be automatically derived by using [`#[derive(SqlType)]`](derive@SqlType)
715/// with the `#[diesel(enum_type)]` attribute
716#[doc = " A marker trait for SQL types representing database side enums"]
#[doc = ""]
#[doc =
" This trait describes how an enum should be mapped to the underlying database storage type"]
#[doc = " by specifying one of a set of different strategies."]
#[doc = ""]
#[doc =
" The generic constant `HAS_EXPLICIT_DISCRIMINANT` can be used to enforce that for a given mapping"]
#[doc =
" the user needs to provide explicit discriminant values. The [`#[derive(Enum)]`](crate::types::Enum) macro"]
#[doc = " will pass the true only if this is the case."]
#[doc = ""]
#[doc =
" The generic type `DB` represents the database backend for which this mapping is valid"]
#[doc = ""]
#[doc = " # Deriving"]
#[doc = ""]
#[doc =
" This trait can be automatically derived by using [`#[derive(SqlType)]`](derive@SqlType)"]
#[doc = " with the `#[diesel(enum_type)]` attribute"]
pub trait EnumSqlType<const HAS_EXPLICIT_DISCRIMINANT : bool,
    DB: Backend>: SqlType {
    /// The mapping strategy used by this type
    ///
    /// This mainly exists to share the logic between different SQL types
    type Strategy: crate::types::enum_::EnumMapping<DB>;
}#[diesel_derives::__diesel_public_if(
717    feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes"
718)]
719// TODO: it seems like `#[diagnostic::on_unimplemented]` doesn't work here
720pub trait EnumSqlType<const HAS_EXPLICIT_DISCRIMINANT: bool, DB: Backend>: SqlType {
721    /// The mapping strategy used by this type
722    ///
723    /// This mainly exists to share the logic between different SQL types
724    type Strategy: crate::types::enum_::EnumMapping<DB>;
725}
726
727/// Is one value of `IsNull` nullable?
728///
729/// You should never implement this trait.
730pub trait OneIsNullable<Other> {
731    /// See the trait documentation
732    type Out: OneIsNullable<is_nullable::IsNullable> + OneIsNullable<is_nullable::NotNull>;
733}
734
735/// Are both values of `IsNull` are nullable?
736pub trait AllAreNullable<Other> {
737    /// See the trait documentation
738    type Out: AllAreNullable<is_nullable::NotNull> + AllAreNullable<is_nullable::IsNullable>;
739}
740
741/// A type level constructor for maybe nullable types
742///
743/// Constructs either `Nullable<O>` (for `Self` == `is_nullable::IsNullable`)
744/// or `O` (for `Self` == `is_nullable::NotNull`)
745pub trait MaybeNullableType<O> {
746    /// See the trait documentation
747    type Out: SqlType + TypedExpressionType;
748}
749
750/// Possible values for `SqlType::IsNullable`
751pub mod is_nullable {
752    use super::*;
753
754    /// No, this type cannot be null as it is marked as `NOT NULL` at database level
755    ///
756    /// This should be chosen for basically all manual impls of `SqlType`
757    /// beside implementing your own `Nullable<>` wrapper type
758    #[derive(#[automatically_derived]
impl ::core::fmt::Debug for NotNull {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "NotNull")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for NotNull {
    #[inline]
    fn clone(&self) -> NotNull { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for NotNull { }Copy)]
759    pub struct NotNull;
760
761    /// Yes, this type can be null
762    ///
763    /// The only diesel provided `SqlType` that uses this value is [`Nullable<T>`]
764    ///
765    /// [`Nullable<T>`]: Nullable
766    #[derive(#[automatically_derived]
impl ::core::fmt::Debug for IsNullable {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "IsNullable")
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for IsNullable {
    #[inline]
    fn clone(&self) -> IsNullable { *self }
}Clone, #[automatically_derived]
impl ::core::marker::Copy for IsNullable { }Copy)]
767    pub struct IsNullable;
768
769    impl OneIsNullable<NotNull> for NotNull {
770        type Out = NotNull;
771    }
772
773    impl OneIsNullable<IsNullable> for NotNull {
774        type Out = IsNullable;
775    }
776
777    impl OneIsNullable<NotNull> for IsNullable {
778        type Out = IsNullable;
779    }
780
781    impl OneIsNullable<IsNullable> for IsNullable {
782        type Out = IsNullable;
783    }
784
785    impl AllAreNullable<NotNull> for NotNull {
786        type Out = NotNull;
787    }
788
789    impl AllAreNullable<IsNullable> for NotNull {
790        type Out = NotNull;
791    }
792
793    impl AllAreNullable<NotNull> for IsNullable {
794        type Out = NotNull;
795    }
796
797    impl AllAreNullable<IsNullable> for IsNullable {
798        type Out = IsNullable;
799    }
800
801    impl<O> MaybeNullableType<O> for NotNull
802    where
803        O: SqlType + TypedExpressionType,
804    {
805        type Out = O;
806    }
807
808    impl<O> MaybeNullableType<O> for IsNullable
809    where
810        O: SqlType,
811        Nullable<O>: TypedExpressionType,
812    {
813        type Out = Nullable<O>;
814    }
815
816    /// Represents the output type of [`MaybeNullableType`]
817    pub type MaybeNullable<N, T> = <N as MaybeNullableType<T>>::Out;
818
819    /// Represents the output type of [`OneIsNullable`]
820    pub type OneNullable<T1, T2> = <T1 as OneIsNullable<T2>>::Out;
821
822    /// Represents the output type of [`OneIsNullable`]
823    /// for two given SQL types
824    pub type IsOneNullable<S1, S2> = OneNullable<IsSqlTypeNullable<S1>, IsSqlTypeNullable<S2>>;
825
826    /// Represents the output type of [`AllAreNullable`]
827    /// for two given SQL types
828    pub type AreAllNullable<S1, S2> =
829        <IsSqlTypeNullable<S1> as AllAreNullable<IsSqlTypeNullable<S2>>>::Out;
830
831    /// Represents if the SQL type is nullable or not
832    pub type IsSqlTypeNullable<T> = <T as SqlType>::IsNull;
833}
834
835/// A marker trait for accepting expressions of the type `Bool` and
836/// `Nullable<Bool>` in the same place
837#[diagnostic::on_unimplemented(
838    message = "`{Self}` is neither `diesel::sql_types::Bool` nor `diesel::sql_types::Nullable<Bool>`",
839    note = "try to provide an expression that produces one of the expected sql types"
840)]
841pub trait BoolOrNullableBool {}
842
843impl BoolOrNullableBool for Bool {}
844impl BoolOrNullableBool for Nullable<Bool> {}
845
846#[doc(inline)]
847pub use crate::expression::expression_types::Untyped;
848
849pub(crate) mod helper {
850    use super::{MaybeNullableType, OneIsNullable, SingleValue};
851
852    pub trait CombinedNullableValue<O, Out>: SingleValue {
853        type Out: SingleValue;
854    }
855
856    impl<T, O, Out> CombinedNullableValue<O, Out> for T
857    where
858        T: SingleValue,
859        O: SingleValue,
860        T::IsNull: OneIsNullable<O::IsNull>,
861        <T::IsNull as OneIsNullable<O::IsNull>>::Out: MaybeNullableType<Out>,
862        <<T::IsNull as OneIsNullable<O::IsNull>>::Out as MaybeNullableType<Out>>::Out: SingleValue,
863    {
864        type Out = <<T::IsNull as OneIsNullable<O::IsNull>>::Out as MaybeNullableType<Out>>::Out;
865    }
866}
diesel/sql_types/mod.rs

diesel/sql_types/
mod.rs
