Add sqlite functions json and jsonb

diesel/Cargo.toml

@@ -24,7 +24,7 @@ include = [
 byteorder = { version = "1.0", optional = true }
 chrono = { version = "0.4.20", optional = true, default-features = false, features = ["clock", "std"] }
 libc = { version = "0.2.0", optional = true }
-libsqlite3-sys = { version = ">=0.17.2, <0.31.0", optional = true, features = ["bundled_bindings"] }
+libsqlite3-sys = { version = ">=0.17.2, <0.31.0", optional = true, features = ["bundled"] }
 mysqlclient-sys = { version = ">=0.2.5, <0.5.0",  optional = true }
 mysqlclient-src = { version = "0.1.0", optional = true }
 pq-sys = { version = ">=0.4.0, <0.7.0", optional = true }

diesel/src/expression/mod.rs

@@ -74,6 +74,9 @@ pub(crate) mod dsl {
     #[cfg(feature = "postgres_backend")]
     pub use crate::pg::expression::dsl::*;
 
+    #[cfg(feature = "sqlite")]
+    pub use crate::sqlite::expression::dsl::*;
+
     /// The return type of [`count(expr)`](crate::dsl::count())
     pub type count<Expr> = super::count::count<SqlTypeOf<Expr>, Expr>;
 

diesel/src/sqlite/expression/expression_methods.rs

@@ -1,5 +1,8 @@
 //! Sqlite specific expression methods.
 
+pub(in crate::sqlite) use self::private::{
+    JsonOrNullableJsonOrJsonbOrNullableJsonb, MaybeNullableValue,
+};
 use super::operators::*;
 use crate::dsl;
 use crate::expression::grouped::Grouped;
@@ -82,3 +85,26 @@ pub trait SqliteExpressionMethods: Expression + Sized {
 }
 
 impl<T: Expression> SqliteExpressionMethods for T {}
+
+pub(in crate::sqlite) mod private {
+    use crate::sql_types::{Json, Jsonb, MaybeNullableType, Nullable, SingleValue};
+
+    pub trait JsonOrNullableJsonOrJsonbOrNullableJsonb {}
+    impl JsonOrNullableJsonOrJsonbOrNullableJsonb for Json {}
+    impl JsonOrNullableJsonOrJsonbOrNullableJsonb for Nullable<Json> {}
+    impl JsonOrNullableJsonOrJsonbOrNullableJsonb for Jsonb {}
+    impl JsonOrNullableJsonOrJsonbOrNullableJsonb for Nullable<Jsonb> {}
+
+    pub trait MaybeNullableValue<T>: SingleValue {
+        type Out: SingleValue;
+    }
+
+    impl<T, O> MaybeNullableValue<O> for T
+    where
+        T: SingleValue,
+        T::IsNull: MaybeNullableType<O>,
+        <T::IsNull as MaybeNullableType<O>>::Out: SingleValue,
+    {
+        type Out = <T::IsNull as MaybeNullableType<O>>::Out;
+    }
+}

diesel/src/sqlite/expression/functions.rs

@@ -0,0 +1,114 @@
+//! SQLite specific functions
+use crate::expression::functions::define_sql_function;
+use crate::sql_types::*;
+use crate::sqlite::expression::expression_methods::JsonOrNullableJsonOrJsonbOrNullableJsonb;
+use crate::sqlite::expression::expression_methods::MaybeNullableValue;
+
+#[cfg(feature = "sqlite")]
+define_sql_function! {
+    /// Verifies that its argument is a valid JSON string or JSONB blob and returns a minified
+    /// version of that JSON string with all unnecessary whitespace removed.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # include!("../../doctest_setup.rs");
+    /// #
+    /// # fn main() {
+    /// #     #[cfg(feature = "serde_json")]
+    /// #     run_test().unwrap();
+    /// # }
+    /// #
+    /// # #[cfg(feature = "serde_json")]
+    /// # fn run_test() -> QueryResult<()> {
+    /// #     use diesel::dsl::json;
+    /// #     use serde_json::{json, Value};
+    /// #     use diesel::sql_types::{Text, Json, Jsonb, Nullable};
+    /// #     let connection = &mut establish_connection();
+    ///
+    /// let result = diesel::select(json::<Json, _>(json!({"a": "b", "c": 1})))
+    ///     .get_result::<String>(connection)?;
+    ///
+    /// assert_eq!(r#"{"a":"b","c":1}"#, result);
+    ///
+    /// let result = diesel::select(json::<Json, _>(json!({ "this" : "is", "a": [ "test" ] })))
+    ///     .get_result::<String>(connection)?;
+    ///
+    /// assert_eq!(r#"{"a":["test"],"this":"is"}"#, result);
+    ///
+    /// let result = diesel::select(json::<Nullable<Json>, _>(None::<Value>))
+    ///     .get_result::<Option<String>>(connection)?;
+    ///
+    /// assert!(result.is_none());
+    ///
+    /// let result = diesel::select(json::<Jsonb, _>(json!({"a": "b", "c": 1})))
+    ///     .get_result::<String>(connection)?;
+    ///
+    /// assert_eq!(r#"{"a":"b","c":1}"#, result);
+    ///
+    /// let result = diesel::select(json::<Jsonb, _>(json!({ "this" : "is", "a": [ "test" ] })))
+    ///     .get_result::<String>(connection)?;
+    ///
+    /// assert_eq!(r#"{"a":["test"],"this":"is"}"#, result);
+    ///
+    /// let result = diesel::select(json::<Nullable<Jsonb>, _>(None::<Value>))
+    ///     .get_result::<Option<String>>(connection)?;
+    ///
+    /// assert!(result.is_none());
+    ///
+    ///
+    /// #     Ok(())
+    /// # }
+    /// ```
+    fn json<E: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue + MaybeNullableValue<Text>>(e: E) -> E::Out;
+}
+
+#[cfg(feature = "sqlite")]
+define_sql_function! {
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # include!("../../doctest_setup.rs");
+    /// #
+    /// # fn main() {
+    /// #     #[cfg(feature = "serde_json")]
+    /// #     run_test().unwrap();
+    /// # }
+    /// #
+    /// # #[cfg(feature = "serde_json")]
+    /// # fn run_test() -> QueryResult<()> {
+    /// #     use diesel::dsl::jsonb;
+    /// #     use serde_json::{json, Value};
+    /// #     use diesel::sql_types::{Text, Json, Jsonb, Nullable};
+    /// #     let connection = &mut establish_connection();
+    ///
+    /// let result = diesel::select(jsonb::<Json, _>(json!({"a": "b", "c": 1})))
+    ///     .get_result::<Value>(connection)?;
+    ///
+    /// assert_eq!(json!({"a": "b", "c": 1}), result);
+    /// println!("json abc1");
+    ///
+    /// let result = diesel::select(jsonb::<Jsonb, _>(json!({"a": "b", "c": 1})))
+    ///     .get_result::<Value>(connection)?;
+    ///
+    /// assert_eq!(json!({"a": "b", "c": 1}), result);
+    /// println!("jsonb abc1");
+    ///
+    /// let result = diesel::select(jsonb::<Nullable<Json>, _>(None::<Value>))
+    ///     .get_result::<Option<Value>>(connection)?;
+    ///
+    /// assert!(result.is_none());
+    /// println!("json null");
+    ///
+    /// let result = diesel::select(jsonb::<Nullable<Jsonb>, _>(None::<Value>))
+    ///     .get_result::<Option<Value>>(connection)?;
+    ///
+    /// assert!(result.is_none());
+    /// println!("jsonb null");
+    ///
+    /// #     Ok(())
+    /// # }
+    /// ```
+    fn jsonb<E: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue + MaybeNullableValue<Jsonb>>(e: E) -> E::Out;
+}

diesel/src/sqlite/expression/helper_types.rs

@@ -1,8 +1,18 @@
-use crate::dsl::AsExpr;
+use crate::dsl::{AsExpr, SqlTypeOf};
 use crate::expression::grouped::Grouped;
 
 /// The return type of `lhs.is(rhs)`.
 pub type Is<Lhs, Rhs> = Grouped<super::operators::Is<Lhs, AsExpr<Rhs, Lhs>>>;
 
 /// The return type of `lhs.is_not(rhs)`.
 pub type IsNot<Lhs, Rhs> = Grouped<super::operators::IsNot<Lhs, AsExpr<Rhs, Lhs>>>;
+
+/// Return type of [`json(json)`](super::functions::json())
+#[allow(non_camel_case_types)]
+#[cfg(feature = "sqlite")]
+pub type json<E> = super::functions::json<SqlTypeOf<E>, E>;
+
+/// Return type of [`jsonb(json)`](super::functions::jsonb())
+#[allow(non_camel_case_types)]
+#[cfg(feature = "sqlite")]
+pub type jsonb<E> = super::functions::jsonb<SqlTypeOf<E>, E>;

diesel/src/sqlite/expression/mod.rs

@@ -5,5 +5,16 @@
 //! kept separate purely for documentation purposes.
 
 pub(crate) mod expression_methods;
+pub mod functions;
 pub(crate) mod helper_types;
 mod operators;
+
+/// SQLite specific expression DSL methods.
+///
+/// This module will be glob imported by
+/// [`diesel::dsl`](crate::dsl) when compiled with the `feature =
+/// "postgres"` flag.
+pub mod dsl {
+    #[doc(inline)]
+    pub use super::functions::*;
+}

diesel/src/sqlite/mod.rs

@@ -6,7 +6,7 @@
 
 pub(crate) mod backend;
 mod connection;
-pub(crate) mod expression;
+pub mod expression;
 
 pub mod query_builder;
 

diesel_derives/tests/auto_type.rs

@@ -57,6 +57,16 @@ table! {
     }
 }
 
+#[cfg(feature = "sqlite")]
+table! {
+    sqlite_extras {
+        id -> Integer,
+        text -> Text,
+        json -> Json,
+        jsonb -> Jsonb,
+    }
+}
+
 joinable!(posts -> users(user_id));
 joinable!(posts2 -> users(user_id));
 joinable!(posts3 -> users(user_id));
@@ -465,6 +475,18 @@ fn postgres_functions() -> _ {
     )
 }
 
+#[cfg(feature = "sqlite")]
+#[auto_type]
+fn sqlite_functions() -> _ {
+    use diesel::sqlite::expression::functions::{json, jsonb};
+    (
+        json(sqlite_extras::json),
+        json(sqlite_extras::jsonb),
+        jsonb(sqlite_extras::json),
+        jsonb(sqlite_extras::jsonb),
+    )
+}
+
 #[auto_type]
 fn with_lifetime<'a>(name: &'a str) -> _ {
     users::table.filter(users::name.eq(name))