diesel/sqlite/expression/

functions.rs

//! SQLite specific functions
#[cfg(doc)]
use crate::expression::functions::aggregate_expressions::AggregateExpressionMethods;
use crate::expression::functions::declare_sql_function;
use crate::expression_methods::json_expression_methods::private::JsonOrNullableJsonOrJsonbOrNullableJsonb;
use crate::sql_types::*;
use crate::sqlite::expression::expression_methods::BinaryOrNullableBinary;
use crate::sqlite::expression::expression_methods::JsonOrNullableJson;
use crate::sqlite::expression::expression_methods::MaybeNullableValue;
use crate::sqlite::expression::expression_methods::NotBlob;
use crate::sqlite::expression::expression_methods::TextOrNullableText;
use crate::sqlite::expression::expression_methods::TextOrNullableTextOrBinaryOrNullableBinary;
use crate::sqlite::expression::functions::helper::CombinedNullableValue;

#[cfg(feature = "__sqlite-shared")]
#[declare_sql_function(generate_return_type_helpers = true)]
#[backends(crate::sqlite::Sqlite)]
extern "SQL" {
    /// 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, Nullable};
    /// #     let connection = &mut establish_connection();
    ///
    /// let result = diesel::select(json::<Text, _>(r#"{"a": "b", "c": 1}"#))
    ///     .get_result::<Value>(connection)?;
    ///
    /// assert_eq!(json!({"a":"b","c":1}), result);
    ///
    /// let result = diesel::select(json::<Text, _>(r#"{ "this" : "is", "a": [ "test" ] }"#))
    ///     .get_result::<Value>(connection)?;
    ///
    /// assert_eq!(json!({"a":["test"],"this":"is"}), result);
    ///
    /// let result = diesel::select(json::<Nullable<Text>, _>(None::<&str>))
    ///     .get_result::<Option<Value>>(connection)?;
    ///
    /// assert!(result.is_none());
    ///
    /// #     Ok(())
    /// # }
    /// ```
    fn json<E: TextOrNullableText + MaybeNullableValue<Json>>(e: E) -> E::Out;

    /// The jsonb(X) function returns the binary JSONB representation of the JSON provided as argument X.
    ///
    /// This function requires at least SQLite 3.45 or newer
    ///
    /// # 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::{sql, jsonb};
    /// #     use serde_json::{json, Value};
    /// #     use diesel::sql_types::{Text, Binary, Nullable};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 45, 0);
    ///
    /// let result = diesel::select(jsonb::<Binary, _>(br#"{"a": "b", "c": 1}"#))
    ///     .get_result::<Value>(connection)?;
    ///
    /// assert_eq!(json!({"a": "b", "c": 1}), result);
    ///
    /// let result = diesel::select(jsonb::<Binary, _>(br#"{"this":"is","a":["test"]}"#))
    ///     .get_result::<Value>(connection)?;
    ///
    /// assert_eq!(json!({"this":"is","a":["test"]}), result);
    ///
    /// let result = diesel::select(jsonb::<Nullable<Binary>, _>(None::<Vec<u8>>))
    ///     .get_result::<Option<Value>>(connection)?;
    ///
    /// assert!(result.is_none());
    ///
    /// #     Ok(())
    /// # }
    /// ```
    fn jsonb<E: BinaryOrNullableBinary + MaybeNullableValue<Jsonb>>(e: E) -> E::Out;

    /// The json_array_length(X) function returns the number of elements in the JSON array X,
    /// or 0 if X is some kind of JSON value other than an array.
    /// Errors are thrown if either X is not well-formed JSON or if P is not a well-formed path.
    ///
    /// This function requires at least SQLite 3.46 or newer
    ///
    /// # 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::{sql, json_array_length};
    /// #     use serde_json::{json, Value};
    /// #     use diesel::sql_types::{Json, Jsonb, Text, Nullable};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 46, 0);
    ///
    /// let result = diesel::select(json_array_length::<Json, _>(json!([1,2,3,4])))
    ///     .get_result::<i32>(connection)?;
    ///
    /// assert_eq!(4, result);
    ///
    /// let result = diesel::select(json_array_length::<Json, _>(json!({"one":[1,2,3]})))
    ///     .get_result::<i32>(connection)?;
    ///
    /// assert_eq!(0, result);
    ///
    /// let result = diesel::select(json_array_length::<Nullable<Json>, _>(None::<Value>))
    ///     .get_result::<Option<i32>>(connection)?;
    ///
    /// assert_eq!(None, result);
    ///
    /// let result = diesel::select(json_array_length::<Jsonb, _>(json!([1,2,3,4])))
    ///     .get_result::<i32>(connection)?;
    ///
    /// assert_eq!(4, result);
    ///
    /// let result = diesel::select(json_array_length::<Jsonb, _>(json!({"one":[1,2,3]})))
    ///     .get_result::<i32>(connection)?;
    ///
    /// assert_eq!(0, result);
    ///
    /// let result = diesel::select(json_array_length::<Nullable<Jsonb>, _>(None::<Value>))
    ///     .get_result::<Option<i32>>(connection)?;
    ///
    /// assert_eq!(None, result);
    ///
    /// #     Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    fn json_array_length<
        J: JsonOrNullableJsonOrJsonbOrNullableJsonb + MaybeNullableValue<Integer>,
    >(
        j: J,
    ) -> J::Out;

    /// The json_array_length(X) function returns the number of elements in the JSON array X,
    /// or 0 if X is some kind of JSON value other than an array.
    /// The json_array_length(X,P) locates the array at path P within X and returns the length of that array,
    /// or 0 if path P locates an element in X that is not a JSON array,
    /// and NULL if path P does not locate any element of X.
    /// Errors are thrown if either X is not well-formed JSON or if P is not a well-formed path.
    ///
    /// This function requires at least SQLite 3.46 or newer
    ///
    /// # 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::{sql, json_array_length_with_path};
    /// #     use serde_json::{json, Value};
    /// #     use diesel::sql_types::{Json, Jsonb, Text, Nullable};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 46, 0);
    ///
    /// let result = diesel::select(json_array_length_with_path::<Json, _, _>(json!([1,2,3,4]), "$"))
    ///     .get_result::<Option<i32>>(connection)?;
    ///
    /// assert_eq!(Some(4), result);
    ///
    /// let result = diesel::select(json_array_length_with_path::<Json, _, _>(json!([1,2,3,4]), "$[2]"))
    ///     .get_result::<Option<i32>>(connection)?;
    ///
    /// assert_eq!(Some(0), result);
    ///
    /// let result = diesel::select(json_array_length_with_path::<Json, _, _>(json!({"one":[1,2,3]}), "$.one"))
    ///     .get_result::<Option<i32>>(connection)?;
    ///
    /// assert_eq!(Some(3), result);
    ///
    /// let result = diesel::select(json_array_length_with_path::<Nullable<Json>, _, _>(json!({"one":[1,2,3]}), "$.two"))
    ///     .get_result::<Option<i32>>(connection)?;
    ///
    /// assert_eq!(None, result);
    ///
    /// let result = diesel::select(json_array_length_with_path::<Jsonb, _, _>(json!([1,2,3,4]), "$"))
    ///     .get_result::<Option<i32>>(connection)?;
    ///
    /// assert_eq!(Some(4), result);
    ///
    /// let result = diesel::select(json_array_length_with_path::<Jsonb, _, _>(json!([1,2,3,4]), "$[2]"))
    ///     .get_result::<Option<i32>>(connection)?;
    ///
    /// assert_eq!(Some(0), result);
    ///
    /// let result = diesel::select(json_array_length_with_path::<Jsonb, _, _>(json!({"one":[1,2,3]}), "$.one"))
    ///     .get_result::<Option<i32>>(connection)?;
    ///
    /// assert_eq!(Some(3), result);
    ///
    /// let result = diesel::select(json_array_length_with_path::<Nullable<Jsonb>, _, _>(json!({"one":[1,2,3]}), "$.two"))
    ///     .get_result::<Option<i32>>(connection)?;
    ///
    /// assert_eq!(None, result);
    ///
    /// #     Ok(())
    /// # }
    /// ```
    #[sql_name = "json_array_length"]
    #[cfg(feature = "__sqlite-shared")]
    fn json_array_length_with_path<J: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue>(
        j: J,
        path: Text,
    ) -> Nullable<Integer>;

    /// The json_error_position(X) function returns 0 if the input X is a well-formed JSON or JSON5 string.
    /// If the input X contains one or more syntax errors, then this function returns the character position of the first syntax error.
    /// The left-most character is position 1.
    ///
    /// If the input X is a BLOB, then this routine returns 0 if X is a well-formed JSONB blob. If the return value is positive,
    /// then it represents the approximate 1-based position in the BLOB of the first detected error.
    ///
    /// This function requires at least SQLite 3.46 or newer
    ///
    /// # 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::{sql, json_error_position};
    /// #     use diesel::sql_types::{Binary, Text, Nullable};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 46, 0);
    ///
    /// let result = diesel::select(json_error_position::<Text, _>(r#"{"a": "b", "c": 1}"#))
    ///     .get_result::<i32>(connection)?;
    ///
    /// assert_eq!(0, result);
    ///
    /// let result = diesel::select(json_error_position::<Text, _>(r#"{"a": b", "c": 1}"#))
    ///     .get_result::<i32>(connection)?;
    ///
    /// assert_eq!(7, result);
    ///
    /// let json5 = r#"
    ///     {
    ///         // A traditional message.
    ///         message: 'hello world',
    ///
    ///         // A number for some reason.
    ///         n: 42,
    ///     }
    /// "#;
    /// let result =
    ///     diesel::select(json_error_position::<Text, _>(json5)).get_result::<i32>(connection)?;
    ///
    /// assert_eq!(0, result);
    ///
    /// let json5_with_error = r#"
    ///     {
    ///         // A traditional message.
    ///         message: hello world',
    ///
    ///         // A number for some reason.
    ///         n: 42,
    ///     }
    /// "#;
    /// let result = diesel::select(json_error_position::<Text, _>(json5_with_error))
    ///     .get_result::<i32>(connection)?;
    ///
    /// assert_eq!(59, result);
    ///
    /// let result = diesel::select(json_error_position::<Nullable<Text>, _>(None::<&str>))
    ///     .get_result::<Option<i32>>(connection)?;
    ///
    /// assert_eq!(None, result);
    ///
    /// let result = diesel::select(json_error_position::<Binary, _>(br#"{"a": "b", "c": 1}"#))
    ///     .get_result::<i32>(connection)?;
    ///
    /// assert_eq!(0, result);
    ///
    /// let result = diesel::select(json_error_position::<Binary, _>(br#"{"a": b", "c": 1}"#))
    ///     .get_result::<i32>(connection)?;
    ///
    /// assert_eq!(7, result);
    ///
    /// let result = diesel::select(json_error_position::<Nullable<Binary>, _>(None::<Vec<u8>>))
    ///     .get_result::<Option<i32>>(connection)?;
    ///
    /// assert_eq!(None, result);
    ///
    /// #     Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    fn json_error_position<
        X: TextOrNullableTextOrBinaryOrNullableBinary + MaybeNullableValue<Integer>,
    >(
        x: X,
    ) -> X::Out;

    /// Extracts a text value from a well-formed JSON document at the given path.
    ///
    /// Returns `NULL` if the path does not exist in the JSON document, or if the value at that
    /// path is a JSON `null`.
    ///
    /// To extract other types, use:
    /// - [`json_extract_integer`](json_extract_integer()) for integer values
    /// - [`json_extract_double`](json_extract_double()) for floating-point values
    /// - [`json_extract_json`](json_extract_json_1()) for JSON objects or arrays
    ///
    /// This function requires at least SQLite 3.9 or newer.
    ///
    /// # 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::*;
    /// #     use diesel::sql_types::{Json, Nullable};
    /// #     use serde_json::{json, Value};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 9, 0);
    ///
    /// let json = json!({"a": "xyz"});
    /// let result = diesel::select(json_extract_string::<Json, _, _>(json, "$.a"))
    ///     .get_result::<Option<String>>(connection)?;
    /// assert_eq!(Some("xyz".to_string()), result);
    ///
    /// let json = json!({"a": 42});
    /// let result = diesel::select(json_extract_string::<Json, _, _>(json, "$.a"))
    ///     .get_result::<Option<String>>(connection)?;
    /// assert_eq!(Some("42".to_string()), result);
    ///
    /// let result = diesel::select(json_extract_string::<Nullable<Json>, _, _>(None::<Value>, "$.a"))
    ///     .get_result::<Option<String>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// let json = json!({"a": "xyz"});
    /// let result = diesel::select(json_extract_string::<Json, _, _>(json, "$.x"))
    ///     .get_result::<Option<String>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// #     Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[sql_name = "json_extract"]
    fn json_extract_string<J: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue>(
        json: J,
        text: Text,
    ) -> Nullable<Text>;

    /// Extracts an integer value from a well-formed JSON document at the given path.
    ///
    /// Returns `NULL` if the path does not exist in the JSON document, or if the value at that
    /// path is a JSON `null`.
    ///
    /// To extract other types, use:
    /// - [`json_extract_string`](json_extract_string()) for text values
    /// - [`json_extract_double`](json_extract_double()) for floating-point values
    /// - [`json_extract_json`](json_extract_json_1()) for JSON objects or arrays
    ///
    /// This function requires at least SQLite 3.9 or newer.
    ///
    /// # 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::*;
    /// #     use diesel::sql_types::{Json, Nullable};
    /// #     use serde_json::{json, Value};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 9, 0);
    ///
    /// let json = json!({"a": 2, "c": [4, 5, {"f": 7}]});
    /// let result = diesel::select(json_extract_integer::<Json, _, _>(json, "$.c[2].f"))
    ///     .get_result::<Option<i32>>(connection)?;
    /// assert_eq!(Some(7), result);
    ///
    /// let json = json!({"a": 3.7});
    /// let result = diesel::select(json_extract_integer::<Json, _, _>(json, "$.a"))
    ///     .get_result::<Option<i32>>(connection)?;
    /// assert_eq!(Some(3), result);
    ///
    /// let result = diesel::select(json_extract_integer::<Nullable<Json>, _, _>(None::<Value>, "$.a"))
    ///     .get_result::<Option<i32>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// let json = json!({"a": 2});
    /// let result = diesel::select(json_extract_integer::<Json, _, _>(json, "$.x"))
    ///     .get_result::<Option<i32>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// #     Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[sql_name = "json_extract"]
    fn json_extract_integer<J: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue>(
        json: J,
        text: Text,
    ) -> Nullable<Integer>;

    /// Extracts a floating-point value from a well-formed JSON document at the given path.
    ///
    /// Returns `NULL` if the path does not exist in the JSON document, or if the value at that
    /// path is a JSON `null`.
    ///
    /// To extract other types, use:
    /// - [`json_extract_string`](json_extract_string()) for text values
    /// - [`json_extract_integer`](json_extract_integer()) for integer values
    /// - [`json_extract_json`](json_extract_json_1()) for JSON objects or arrays
    ///
    /// This function requires at least SQLite 3.9 or newer.
    ///
    /// # 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::*;
    /// #     use diesel::sql_types::{Json, Nullable};
    /// #     use serde_json::{json, Value};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 9, 0);
    ///
    /// let json = json!({"a": 3.14});
    /// let result = diesel::select(json_extract_double::<Json, _, _>(json, "$.a"))
    ///     .get_result::<Option<f64>>(connection)?;
    /// assert_eq!(Some(3.14), result);
    ///
    /// let json = json!({"a": 7});
    /// let result = diesel::select(json_extract_double::<Json, _, _>(json, "$.a"))
    ///     .get_result::<Option<f64>>(connection)?;
    /// assert_eq!(Some(7.0), result);
    ///
    /// let result = diesel::select(json_extract_double::<Nullable<Json>, _, _>(None::<Value>, "$.a"))
    ///     .get_result::<Option<f64>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// let json = json!({"a": 3.14});
    /// let result = diesel::select(json_extract_double::<Json, _, _>(json, "$.x"))
    ///     .get_result::<Option<f64>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// #     Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[sql_name = "json_extract"]
    fn json_extract_double<J: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue>(
        json: J,
        text: Text,
    ) -> Nullable<Double>;

    /// Extracts a JSON object or array from a well-formed JSON document at the given path.
    ///
    /// When a single path is provided, returns the value at that path as a [`Json`] value.
    /// When multiple paths are provided (using the variadic form), returns a JSON array
    /// containing the extracted values.
    ///
    /// Returns `NULL` if a single path does not exist in the JSON document. With multiple paths,
    /// missing paths appear as `null` inside the returned JSON array.
    ///
    /// To extract other types, use:
    /// - [`json_extract_string`](json_extract_string()) for text values
    /// - [`json_extract_integer`](json_extract_integer()) for integer values
    /// - [`json_extract_double`](json_extract_double()) for floating-point values
    ///
    /// This function requires at least SQLite 3.9 or newer.
    ///
    /// # 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::*;
    /// #     use diesel::sql_types::{Json, Nullable};
    /// #     use serde_json::{json, Value};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 9, 0);
    ///
    /// let json = json!({"a": 2, "c": [4, 5, {"f": 7}]});
    /// let result = diesel::select(json_extract_json_1::<Json, _, _>(json, "$.c[2]"))
    ///     .get_result::<Option<Value>>(connection)?;
    /// assert_eq!(Some(json!({"f": 7})), result);
    ///
    /// let json = json!({"a": 2, "c": [4, 5], "f": 7});
    /// let result = diesel::select(json_extract_json_2::<Json, _, _, _>(json, "$.c", "$.a"))
    ///     .get_result::<Option<Value>>(connection)?;
    /// assert_eq!(Some(json!([[4, 5], 2])), result);
    ///
    /// let json = json!({"a": 42});
    /// let result = diesel::select(json_extract_json_1::<Json, _, _>(json, "$.a"))
    ///     .get_result::<Option<Value>>(connection)?;
    /// assert_eq!(Some(json!(42)), result);
    ///
    /// let json = json!({"a": 42});
    /// let result = diesel::select(json_extract_json_2::<Json, _, _, _>(json, "$.a", "$.b"))
    ///     .get_result::<Option<Value>>(connection)?;
    /// assert_eq!(Some(json!([42, null])), result);
    ///
    /// let result = diesel::select(json_extract_json_1::<Nullable<Json>, _, _>(None::<Value>, "$.a"))
    ///     .get_result::<Option<Value>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// let json = json!({"a": 42});
    /// let result = diesel::select(json_extract_json_1::<Json, _, _>(json, "$.x"))
    ///     .get_result::<Option<Value>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// let json = json!({"a": 42});
    /// let result = diesel::select(json_extract_json_2::<Json, _, _, _>(json, "$.b", "$.c"))
    ///     .get_result::<Option<Value>>(connection)?;
    /// assert_eq!(Some(json!([null, null])), result);
    ///
    /// #     Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[sql_name = "json_extract"]
    #[variadic(last_arguments = 1, skip_zero_argument_variant = true)]
    fn json_extract_json<J: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue>(
        json: J,
        text: Text,
    ) -> Nullable<Json>;

    /// Extracts a text value from a well-formed JSON or JSONB document at the given path.
    ///
    /// Works identically to [`json_extract_string`](json_extract_string()) for scalar text values.
    ///
    /// Returns `NULL` if the path does not exist in the JSON document, or if the value at that
    /// path is a JSON `null`.
    ///
    /// To extract other types, use:
    /// - [`jsonb_extract_integer`](jsonb_extract_integer()) for integer values
    /// - [`jsonb_extract_double`](jsonb_extract_double()) for floating-point values
    /// - [`jsonb_extract_jsonb`](jsonb_extract_jsonb_1()) for JSON objects or arrays in JSONB format
    ///
    /// This function requires at least SQLite 3.9 or newer.
    ///
    /// # 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::*;
    /// #     use diesel::sql_types::{Json, Nullable};
    /// #     use serde_json::{json, Value};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 9, 0);
    ///
    /// let json = json!({"a": "xyz"});
    /// let result = diesel::select(jsonb_extract_string::<Json, _, _>(json, "$.a"))
    ///     .get_result::<Option<String>>(connection)?;
    /// assert_eq!(Some("xyz".to_string()), result);
    ///
    /// let json = json!({"a": 42});
    /// let result = diesel::select(jsonb_extract_string::<Json, _, _>(json, "$.a"))
    ///     .get_result::<Option<String>>(connection)?;
    /// assert_eq!(Some("42".to_string()), result);
    ///
    /// let result = diesel::select(jsonb_extract_string::<Nullable<Json>, _, _>(None::<Value>, "$.a"))
    ///     .get_result::<Option<String>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// let json = json!({"a": "xyz"});
    /// let result = diesel::select(jsonb_extract_string::<Json, _, _>(json, "$.x"))
    ///     .get_result::<Option<String>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// #     Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[sql_name = "jsonb_extract"]
    fn jsonb_extract_string<J: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue>(
        json: J,
        text: Text,
    ) -> Nullable<Text>;

    /// Extracts an integer value from a well-formed JSON or JSONB document at the given path.
    ///
    /// Works identically to [`json_extract_integer`](json_extract_integer()) for integer values.
    ///
    /// Returns `NULL` if the path does not exist in the JSON document, or if the value at that
    /// path is a JSON `null`.
    ///
    /// To extract other types, use:
    /// - [`jsonb_extract_string`](jsonb_extract_string()) for text values
    /// - [`jsonb_extract_double`](jsonb_extract_double()) for floating-point values
    /// - [`jsonb_extract_jsonb`](jsonb_extract_jsonb_1()) for JSON objects or arrays in JSONB format
    ///
    /// This function requires at least SQLite 3.9 or newer.
    ///
    /// # 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::*;
    /// #     use diesel::sql_types::{Json, Nullable};
    /// #     use serde_json::{json, Value};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 9, 0);
    ///
    /// let json = json!({"a": 2, "c": [4, 5, {"f": 7}]});
    /// let result = diesel::select(jsonb_extract_integer::<Json, _, _>(json, "$.c[2].f"))
    ///     .get_result::<Option<i32>>(connection)?;
    /// assert_eq!(Some(7), result);
    ///
    /// let json = json!({"a": 3.7});
    /// let result = diesel::select(jsonb_extract_integer::<Json, _, _>(json, "$.a"))
    ///     .get_result::<Option<i32>>(connection)?;
    /// assert_eq!(Some(3), result);
    ///
    /// let result = diesel::select(jsonb_extract_integer::<Nullable<Json>, _, _>(None::<Value>, "$.a"))
    ///     .get_result::<Option<i32>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// let json = json!({"a": 2});
    /// let result = diesel::select(jsonb_extract_integer::<Json, _, _>(json, "$.x"))
    ///     .get_result::<Option<i32>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// #     Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[sql_name = "jsonb_extract"]
    fn jsonb_extract_integer<J: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue>(
        json: J,
        text: Text,
    ) -> Nullable<Integer>;

    /// Extracts a floating-point value from a well-formed JSON or JSONB document at the given path.
    ///
    /// Works identically to [`json_extract_double`](json_extract_double()) for floating-point values.
    ///
    /// Returns `NULL` if the path does not exist in the JSON document, or if the value at that
    /// path is a JSON `null`.
    ///
    /// To extract other types, use:
    /// - [`jsonb_extract_string`](jsonb_extract_string()) for text values
    /// - [`jsonb_extract_integer`](jsonb_extract_integer()) for integer values
    /// - [`jsonb_extract_jsonb`](jsonb_extract_jsonb_1()) for JSON objects or arrays in JSONB format
    ///
    /// This function requires at least SQLite 3.9 or newer.
    ///
    /// # 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::*;
    /// #     use diesel::sql_types::{Json, Nullable};
    /// #     use serde_json::{json, Value};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 9, 0);
    ///
    /// let json = json!({"a": 3.14});
    /// let result = diesel::select(jsonb_extract_double::<Json, _, _>(json, "$.a"))
    ///     .get_result::<Option<f64>>(connection)?;
    /// assert_eq!(Some(3.14), result);
    ///
    /// let json = json!({"a": 7});
    /// let result = diesel::select(jsonb_extract_double::<Json, _, _>(json, "$.a"))
    ///     .get_result::<Option<f64>>(connection)?;
    /// assert_eq!(Some(7.0), result);
    ///
    /// let result = diesel::select(jsonb_extract_double::<Nullable<Json>, _, _>(None::<Value>, "$.a"))
    ///     .get_result::<Option<f64>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// let json = json!({"a": 3.14});
    /// let result = diesel::select(jsonb_extract_double::<Json, _, _>(json, "$.x"))
    ///     .get_result::<Option<f64>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// #     Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[sql_name = "jsonb_extract"]
    fn jsonb_extract_double<J: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue>(
        json: J,
        text: Text,
    ) -> Nullable<Double>;

    /// Extracts a JSON object or array from a well-formed JSON or JSONB document at the given path,
    /// returning it in JSONB format.
    ///
    /// Unlike [`json_extract_json`](json_extract_json_1()), which returns JSON objects and arrays
    /// as text, this function returns them in the internal JSONB binary format. For scalar values
    /// (text, integer, double, null), both functions behave identically.
    ///
    /// When a single path is provided, returns the value at that path as a [`Jsonb`] value.
    /// When multiple paths are provided (using the variadic form), returns a JSONB array
    /// containing the extracted values.
    ///
    /// Returns `NULL` if a single path does not exist in the JSON document. With multiple paths,
    /// missing paths appear as `null` inside the returned JSONB array.
    ///
    /// To extract other types, use:
    /// - [`jsonb_extract_string`](jsonb_extract_string()) for text values
    /// - [`jsonb_extract_integer`](jsonb_extract_integer()) for integer values
    /// - [`jsonb_extract_double`](jsonb_extract_double()) for floating-point values
    ///
    /// This function requires at least SQLite 3.9 or newer.
    ///
    /// # 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::*;
    /// #     use diesel::sql_types::{Json, Jsonb, Nullable};
    /// #     use serde_json::{json, Value};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 9, 0);
    ///
    /// let json = json!({"a": 2, "c": [4, 5, {"f": 7}]});
    /// let result = diesel::select(jsonb_extract_jsonb_1::<Json, _, _>(json, "$"))
    ///     .get_result::<Option<Value>>(connection)?;
    /// assert_eq!(Some(json!({"a": 2, "c": [4, 5, {"f": 7}]})), result);
    ///
    /// let json = json!({"a": 2, "c": [4, 5, {"f": 7}]});
    /// let result = diesel::select(jsonb_extract_jsonb_1::<Json, _, _>(json, "$.c"))
    ///     .get_result::<Option<Value>>(connection)?;
    /// assert_eq!(Some(json!([4, 5, {"f": 7}])), result);
    ///
    /// let json = json!({"a": 2, "c": [4, 5, {"f": 7}]});
    /// let result = diesel::select(jsonb_extract_jsonb_1::<Json, _, _>(json, "$.c[2]"))
    ///     .get_result::<Option<Value>>(connection)?;
    /// assert_eq!(Some(json!({"f": 7})), result);
    ///
    /// let json = json!({"a": 2, "c": [4, 5]});
    /// let result = diesel::select(jsonb_extract_jsonb_2::<Json, _, _, _>(json, "$.c", "$.x"))
    ///     .get_result::<Option<Value>>(connection)?;
    /// assert_eq!(Some(json!([[4, 5], null])), result);
    ///
    /// let result = diesel::select(jsonb_extract_jsonb_1::<Nullable<Json>, _, _>(None::<Value>, "$.a"))
    ///     .get_result::<Option<Value>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// let json = json!({"a": 2, "c": [4, 5, {"f": 7}]});
    /// let result = diesel::select(jsonb_extract_jsonb_1::<Json, _, _>(json, "$.x"))
    ///     .get_result::<Option<Value>>(connection)?;
    /// assert_eq!(None, result);
    ///
    /// let json = json!({"a": 2, "c": [4, 5], "f": 7});
    /// let result = diesel::select(jsonb_extract_jsonb_2::<Json, _, _, _>(json, "$.c", "$.a"))
    ///     .get_result::<Option<Value>>(connection)?;
    /// assert_eq!(Some(json!([[4, 5], 2])), result);
    ///
    /// let json = json!({"a": 2});
    /// let result = diesel::select(jsonb_extract_jsonb_2::<Json, _, _, _>(json, "$.b", "$.c"))
    ///     .get_result::<Option<Value>>(connection)?;
    /// assert_eq!(Some(json!([null, null])), result);
    ///
    /// #     Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[sql_name = "jsonb_extract"]
    #[variadic(last_arguments = 1, skip_zero_argument_variant = true)]
    fn jsonb_extract_jsonb<J: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue>(
        json: J,
        text: Text,
    ) -> Nullable<Jsonb>;

    /// Converts the given json value to pretty-printed, indented text
    ///
    /// This function requires at least SQLite 3.46 or newer
    ///
    /// # 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::{sql, json_pretty};
    /// #     use serde_json::{json, Value};
    /// #     use diesel::sql_types::{Text, Json, Jsonb, Nullable};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 46, 0);
    ///
    /// let result = diesel::select(json_pretty::<Json, _>(json!([{"f1":1,"f2":null},2,null,3])))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"[
    ///     {
    ///         "f1": 1,
    ///         "f2": null
    ///     },
    ///     2,
    ///     null,
    ///     3
    /// ]"#, result);
    ///
    /// let result = diesel::select(json_pretty::<Json, _>(json!({"a": 1, "b": "cd"})))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"{
    ///     "a": 1,
    ///     "b": "cd"
    /// }"#, result);
    ///
    /// let result = diesel::select(json_pretty::<Json, _>(json!("abc")))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#""abc""#, result);
    ///
    /// let result = diesel::select(json_pretty::<Json, _>(json!(22)))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"22"#, result);
    ///
    /// let result = diesel::select(json_pretty::<Json, _>(json!(false)))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"false"#, result);
    ///
    /// let result = diesel::select(json_pretty::<Json, _>(json!(null)))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"null"#, result);
    ///
    /// let result = diesel::select(json_pretty::<Json, _>(json!({})))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"{}"#, result);
    ///
    /// let result = diesel::select(json_pretty::<Nullable<Json>, _>(None::<Value>))
    ///     .get_result::<Option<String>>(connection)?;
    ///
    /// assert!(result.is_none());
    ///
    /// let result = diesel::select(json_pretty::<Jsonb, _>(json!([{"f1":1,"f2":null},2,null,3])))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"[
    ///     {
    ///         "f1": 1,
    ///         "f2": null
    ///     },
    ///     2,
    ///     null,
    ///     3
    /// ]"#, result);
    ///
    /// let result = diesel::select(json_pretty::<Jsonb, _>(json!({"a": 1, "b": "cd"})))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"{
    ///     "a": 1,
    ///     "b": "cd"
    /// }"#, result);
    ///
    /// let result = diesel::select(json_pretty::<Jsonb, _>(json!("abc")))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#""abc""#, result);
    ///
    /// let result = diesel::select(json_pretty::<Jsonb, _>(json!(22)))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"22"#, result);
    ///
    /// let result = diesel::select(json_pretty::<Jsonb, _>(json!(false)))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"false"#, result);
    ///
    /// let result = diesel::select(json_pretty::<Jsonb, _>(json!(null)))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"null"#, result);
    ///
    /// let result = diesel::select(json_pretty::<Jsonb, _>(json!({})))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"{}"#, result);
    ///
    /// let result = diesel::select(json_pretty::<Nullable<Jsonb>, _>(None::<Value>))
    ///     .get_result::<Option<String>>(connection)?;
    ///
    /// assert!(result.is_none());
    /// #     Ok(())
    /// # }
    /// ```
    fn json_pretty<J: JsonOrNullableJsonOrJsonbOrNullableJsonb + MaybeNullableValue<Text>>(
        j: J,
    ) -> J::Out;

    /// Converts the given json value to pretty-printed, indented text
    ///
    /// This function requires at least SQLite 3.46 or newer
    ///
    /// # 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::{sql, json_pretty_with_indentation};
    /// #     use serde_json::{json, Value};
    /// #     use diesel::sql_types::{Text, Json, Jsonb, Nullable};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 46, 0);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Json, _, _>(json!([{"f1":1,"f2":null},2,null,3]), "  "))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"[
    ///   {
    ///     "f1": 1,
    ///     "f2": null
    ///   },
    ///   2,
    ///   null,
    ///   3
    /// ]"#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Json, _, _>(json!([{"f1":1,"f2":null},2,null,3]), None::<&str>))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"[
    ///     {
    ///         "f1": 1,
    ///         "f2": null
    ///     },
    ///     2,
    ///     null,
    ///     3
    /// ]"#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Json, _, _>(json!({"a": 1, "b": "cd"}), "  "))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"{
    ///   "a": 1,
    ///   "b": "cd"
    /// }"#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Json, _, _>(json!("abc"), "  "))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#""abc""#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Json, _, _>(json!(22), "  "))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"22"#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Json, _, _>(json!(false), None::<&str>))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"false"#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Json, _, _>(json!(null), None::<&str>))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"null"#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Json, _, _>(json!({}), "  "))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"{}"#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Nullable<Json>, _, _>(None::<Value>, None::<&str>))
    ///     .get_result::<Option<String>>(connection)?;
    ///
    /// assert!(result.is_none());
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Jsonb, _, _>(json!([{"f1":1,"f2":null},2,null,3]), "  "))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"[
    ///   {
    ///     "f1": 1,
    ///     "f2": null
    ///   },
    ///   2,
    ///   null,
    ///   3
    /// ]"#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Jsonb, _, _>(json!([{"f1":1,"f2":null},2,null,3]), None::<&str>))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"[
    ///     {
    ///         "f1": 1,
    ///         "f2": null
    ///     },
    ///     2,
    ///     null,
    ///     3
    /// ]"#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Jsonb, _, _>(json!({"a": 1, "b": "cd"}), "  "))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"{
    ///   "a": 1,
    ///   "b": "cd"
    /// }"#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Jsonb, _, _>(json!("abc"), "  "))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#""abc""#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Jsonb, _, _>(json!(22), "  "))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"22"#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Jsonb, _, _>(json!(false), None::<&str>))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"false"#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Jsonb, _, _>(json!(null), None::<&str>))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"null"#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Jsonb, _, _>(json!({}), "  "))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!(r#"{}"#, result);
    ///
    /// let result = diesel::select(json_pretty_with_indentation::<Nullable<Jsonb>, _, _>(None::<Value>, None::<&str>))
    ///     .get_result::<Option<String>>(connection)?;
    ///
    /// assert!(result.is_none());
    ///
    /// #     Ok(())
    /// # }
    /// ```
    #[sql_name = "json_pretty"]
    fn json_pretty_with_indentation<
        J: JsonOrNullableJsonOrJsonbOrNullableJsonb + MaybeNullableValue<Text>,
    >(
        j: J,
        indentation: Nullable<Text>,
    ) -> J::Out;

    /// Returns  `true`  if the argument is well-formed JSON, or returns  `false`  if is not well-formed.
    ///
    /// This function requires at least SQLite 3.46 or newer
    ///
    /// # 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::{sql, json_valid};
    /// #     use serde_json::{json, Value};
    /// #     use diesel::sql_types::{Text, Json, Jsonb, Nullable};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 46, 0);
    ///
    /// let result = diesel::select(json_valid::<Json, _>(json!({"x":35})))
    ///     .get_result::<bool>(connection)?;
    ///
    /// assert_eq!(true, result);
    ///
    /// let result = diesel::select(json_valid::<Nullable<Json>, _>(None::<serde_json::Value>))
    ///     .get_result::<Option<bool>>(connection)?;
    ///
    /// assert_eq!(None, result);
    ///
    /// # Ok(())
    /// # }
    /// ```
    #[sql_name = "json_valid"]
    #[cfg(feature = "__sqlite-shared")]
    fn json_valid<J: JsonOrNullableJson + MaybeNullableValue<Bool>>(j: J) -> J::Out;

    /// The json_valid(X,Y) function returns 1 if the argument X is well-formed JSON, or returns 0 if X is not well-formed.
    /// The Y parameter is an integer bitmask that defines what is meant by "well-formed".
    ///
    /// The following bits of Y are currently defined:
    /// - 0x01 → The input is text that strictly complies with canonical RFC-8259 JSON, without any extensions.
    /// - 0x02 → The input is text that is JSON with JSON5 extensions.
    /// - 0x04 → The input is a BLOB that superficially appears to be JSONB.
    /// - 0x08 → The input is a BLOB that strictly conforms to the internal JSONB format.
    ///
    /// By combining bits, the following useful values of Y can be derived:
    /// - 1 → X is RFC-8259 JSON text
    /// - 2 → X is JSON5 text
    /// - 4 → X is probably JSONB
    /// - 5 → X is RFC-8259 JSON text or JSONB
    /// - 6 → X is JSON5 text or JSONB (recommended for most use cases)
    /// - 8 → X is strictly conforming JSONB
    /// - 9 → X is RFC-8259 or strictly conforming JSONB
    /// - 10 → X is JSON5 or strictly conforming JSONB
    ///
    /// The Y parameter must be between 1 and 15 (inclusive), or an error is raised.
    ///
    /// If either X or Y inputs are NULL, then the function returns NULL.
    ///
    /// This function requires at least SQLite 3.46 or newer
    ///
    /// # 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::{sql, json_valid_with_flags};
    /// #     use diesel::sqlite::JsonValidFlag;
    /// #     use serde_json::{json, Value};
    /// #     use diesel::sql_types::{Text, Json, Jsonb, Nullable};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 46, 0);
    ///
    /// // Standard RFC-8259 JSON
    /// let result = diesel::select(json_valid_with_flags::<Text, _, _>(r#"{"x":35}"#, JsonValidFlag::Rfc8259Json))
    ///     .get_result::<bool>(connection)?;
    /// assert_eq!(true, result);
    ///
    /// // JSON5 not valid as RFC-8259
    /// let result = diesel::select(json_valid_with_flags::<Text, _, _>(r#"{x:35}"#, JsonValidFlag::Rfc8259Json))
    ///     .get_result::<bool>(connection)?;
    /// assert_eq!(false, result);
    ///
    /// // JSON5 valid with JSON5 flag
    /// let result = diesel::select(json_valid_with_flags::<Text, _, _>(r#"{x:35}"#, JsonValidFlag::Json5OrJsonb))
    ///     .get_result::<bool>(connection)?;
    /// assert_eq!(true, result);
    ///
    /// // Invalid JSON
    /// let result = diesel::select(json_valid_with_flags::<Text, _, _>(r#"{"x":35"#, JsonValidFlag::Rfc8259Json))
    ///     .get_result::<bool>(connection)?;
    /// assert_eq!(false, result);
    ///
    /// // NULL input returns NULL
    /// let result = diesel::select(json_valid_with_flags::<Nullable<Text>, _, _>(None::<&str>, JsonValidFlag::Rfc8259Json))
    ///     .get_result::<Option<bool>>(connection)?;
    /// assert_eq!(None, result);
    ///
    /// # Ok(())
    /// # }
    /// ```
    #[sql_name = "json_valid"]
    #[cfg(feature = "__sqlite-shared")]
    fn json_valid_with_flags<
        X: TextOrNullableTextOrBinaryOrNullableBinary + SingleValue + MaybeNullableValue<Bool>,
    >(
        x: X,
        flags: crate::sqlite::types::JsonValidFlags,
    ) -> X::Out;

    /// The json_type(X) function returns the "type" of the outermost element of X.
    /// The "type" returned by json_type() is one of the following SQL text values:
    /// 'null', 'true', 'false', 'integer', 'real', 'text', 'array', or 'object'.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// # 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::{sql, json_type};
    /// #     use serde_json::{json, Value};
    /// #     use diesel::sql_types::{Text, Json, Jsonb, Nullable};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    ///
    /// let result = diesel::select(json_type::<Json, _>(json!({"a": [2, 3.5, true, false, null, "x"]})))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!("object", result);
    ///
    /// let result = diesel::select(json_type::<Jsonb, _>(json!({"a": [2, 3.5, true, false, null, "x"]})))
    ///     .get_result::<String>(connection)?;
    ///
    /// assert_eq!("object", result);
    ///
    /// let result = diesel::select(json_type::<Nullable<Json>, _>(None::<serde_json::Value>))
    ///     .get_result::<Option<String>>(connection)?;
    ///
    /// assert_eq!(None, result);
    ///
    /// # Ok(())
    /// # }
    /// ```
    #[sql_name = "json_type"]
    #[cfg(feature = "__sqlite-shared")]
    fn json_type<J: JsonOrNullableJsonOrJsonbOrNullableJsonb + MaybeNullableValue<Text>>(
        j: J,
    ) -> J::Out;

    /// The json_type(X,P) function returns the "type" of the element in X that is selected by path P.
    /// If the path P in json_type(X,P) selects an element that does not exist in X, then this function returns NULL.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// # 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::{sql, json_type_with_path};
    /// #     use serde_json::{json, Value};
    /// #     use diesel::sql_types::{Text, Json, Jsonb, Nullable};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    ///
    /// let json_value = json!({"a": [2, 3.5, true, false, null, "x"]});
    ///
    /// let result = diesel::select(json_type_with_path::<Json, _, _>(json_value.clone(), "$.a"))
    ///     .get_result::<Option<String>>(connection)?;
    ///
    /// assert_eq!(Some("array".to_string()), result);
    ///
    /// let result = diesel::select(json_type_with_path::<Json, _, _>(json_value.clone(), "$.a[0]"))
    ///     .get_result::<Option<String>>(connection)?;
    ///
    /// assert_eq!(Some("integer".to_string()), result);
    ///
    /// let result = diesel::select(json_type_with_path::<Json, _, _>(json_value.clone(), "$.a[1]"))
    ///     .get_result::<Option<String>>(connection)?;
    ///
    /// assert_eq!(Some("real".to_string()), result);
    ///
    /// let result = diesel::select(json_type_with_path::<Json, _, _>(json_value.clone(), "$.a[2]"))
    ///     .get_result::<Option<String>>(connection)?;
    ///
    /// assert_eq!(Some("true".to_string()), result);
    ///
    /// let result = diesel::select(json_type_with_path::<Json, _, _>(json_value.clone(), "$.a[6]"))
    ///     .get_result::<Option<String>>(connection)?;
    ///
    /// assert_eq!(None, result);
    ///
    /// let result = diesel::select(json_type_with_path::<Jsonb, _, _>(json_value.clone(), "$.a"))
    ///     .get_result::<Option<String>>(connection)?;
    ///
    /// assert_eq!(Some("array".to_string()), result);
    ///
    /// let result = diesel::select(json_type_with_path::<Nullable<Json>, _, _>(None::<serde_json::Value>, "$.a"))
    ///     .get_result::<Option<String>>(connection)?;
    ///
    /// assert_eq!(None, result);
    ///
    /// # Ok(())
    /// # }
    /// ```
    #[sql_name = "json_type"]
    #[cfg(feature = "__sqlite-shared")]
    fn json_type_with_path<J: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue>(
        j: J,
        path: Text,
    ) -> Nullable<Text>;

    /// The json_quote(X) function converts the SQL value X (a number or a string) into its corresponding JSON
    /// representation. If X is a JSON value returned by another JSON function, then this function is a no-op.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// # 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::{sql, json_quote};
    /// #     use serde_json::{json, Value};
    /// #     use diesel::sql_types::{Text, Json, Integer, Float, Double, Nullable};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    ///
    /// let result = diesel::select(json_quote::<Integer, _>(42))
    ///     .get_result::<Value>(connection)?;
    /// assert_eq!(json!(42), result);
    ///
    /// let result = diesel::select(json_quote::<Text, _>("verdant"))
    ///     .get_result::<Value>(connection)?;
    /// assert_eq!(json!("verdant"), result);
    ///
    /// let result = diesel::select(json_quote::<Text, _>("[1]"))
    ///     .get_result::<Value>(connection)?;
    /// assert_eq!(json!("[1]"), result);
    ///
    /// let result = diesel::select(json_quote::<Nullable<Text>, _>(None::<&str>))
    ///     .get_result::<Value>(connection)?;
    /// assert_eq!(json!(null), result);
    ///
    /// let result = diesel::select(json_quote::<Double, _>(3.14159))
    ///     .get_result::<Value>(connection)?;
    /// assert_eq!(json!(3.14159), result);
    ///
    /// let result = diesel::select(json_quote::<Json, _>(json!([1])))
    ///     .get_result::<Value>(connection)?;
    // assert_eq!(json!([1]), result);
    ///
    ///
    /// # Ok(())
    /// # }
    /// ```
    #[sql_name = "json_quote"]
    #[cfg(feature = "__sqlite-shared")]
    fn json_quote<J: SqlType + SingleValue>(j: J) -> Json;

    /// The `json_group_array(X)` function is an aggregate SQL function that returns a JSON array comprised of
    /// all X values in the aggregation.
    ///
    /// ## Aggregate Function Expression
    ///
    /// This function can be used as aggregate expression. See [`AggregateExpressionMethods`] for details.
    ///
    /// # Examples
    ///
    /// ## Normal function usage
    ///
    /// ```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::*;
    /// #     use schema::animals::dsl::*;
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #
    /// let result = animals
    ///     .select(json_group_array(species))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(result, json!(["dog", "spider"]));
    ///
    /// let result = animals
    ///     .select(json_group_array(legs))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(result, json!([4, 8]));
    ///
    /// let result = animals
    ///     .select(json_group_array(name))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(result, json!(["Jack", null]));
    ///
    /// # Ok(())
    /// # }
    /// ```
    /// ## Aggregate function expression
    ///
    /// ```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::*;
    /// #     use schema::animals::dsl::*;
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #
    /// let result = animals
    ///     .select(json_group_array(species).aggregate_filter(legs.lt(8)))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(result, json!(["dog"]));
    ///
    /// # Ok(())
    /// # }
    /// ```
    ///
    /// # See also
    /// - [`jsonb_group_array`](jsonb_group_array()) will return data in JSONB format instead of JSON.
    /// - [`json_group_object`](json_group_object()) will return JSON object instead of array.
    #[cfg(feature = "__sqlite-shared")]
    #[aggregate]
    fn json_group_array<E: SqlType + SingleValue>(elements: E) -> Json;

    /// The `jsonb_group_array(X)` function is an aggregate SQL function that returns a JSONB array comprised of
    /// all X values in the aggregation.
    ///
    /// ## Aggregate Function Expression
    ///
    /// This function can be used as aggregate expression. See [`AggregateExpressionMethods`] for details.
    ///
    /// # Examples
    ///
    /// ## Normal function usage
    ///
    /// ```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::*;
    /// #     use schema::animals::dsl::*;
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #
    /// let result = animals
    ///     .select(json_group_array(species))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(result, json!(["dog", "spider"]));
    ///
    /// let result = animals
    ///     .select(json_group_array(legs))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(result, json!([4, 8]));
    ///
    /// let result = animals
    ///     .select(json_group_array(name))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(result, json!(["Jack", null]));
    ///
    /// # Ok(())
    /// # }
    /// ```
    ///
    /// ## Aggregate function expression
    ///
    /// ```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::*;
    /// #     use schema::animals::dsl::*;
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #
    /// let result = animals
    ///     .select(json_group_array(species).aggregate_filter(legs.lt(8)))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(result, json!(["dog"]));
    ///
    /// # Ok(())
    /// # }
    /// ```
    ///
    /// # See also
    /// - [`json_group_array`](json_group_array()) will return data in JSON format instead of JSONB.
    /// - [`jsonb_group_object`](jsonb_group_object()) will return JSONB object instead of array.
    #[cfg(feature = "__sqlite-shared")]
    #[aggregate]
    fn jsonb_group_array<E: SqlType + SingleValue>(elements: E) -> Jsonb;

    /// The `json_object()` SQL function accepts zero or more pairs of arguments and returns a
    /// well-formed JSON object composed from those pairs. The first argument of each pair is the
    /// label (key) and the second argument is the value. If any argument to `json_object()` is a
    /// BLOB then an error is thrown.
    ///
    /// An argument with SQL type TEXT is normally converted into a quoted JSON string even if the
    /// input text is well-formed JSON. However, if the argument is the direct result from another
    /// JSON function, then it is treated as JSON and all of its JSON type information and
    /// substructure is preserved. This allows calls to `json_object()` and `json_array()` to be
    /// nested. The [`json()`] function can also be used to force strings to be recognized as JSON.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// # Examples
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::{Text, Integer};
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    /// #
    /// let result = diesel::select(json_object_0()).get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({}), result);
    ///
    /// let result = diesel::select(json_object_1::<Text, Integer, _, _>("a", 2))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 2}), result);
    ///
    /// let result = diesel::select(
    ///     json_object_2::<Text, Integer, Text, Text, _, _, _, _>("a", 2, "c", "{e:5}")
    /// )
    /// .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 2, "c": "{e:5}"}), result);
    ///
    /// let result = diesel::select(
    ///     json_object_2::<Text, Integer, Text, Json, _, _, _, _>("a", 2, "c", json_object_1::<Text, Integer, _, _>("e", 5))
    /// )
    /// .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 2, "c": {"e": 5}}), result);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[variadic(2)]
    fn json_object<K: NotBlob<IsNull = is_nullable::NotNull>, V: NotBlob>(key: K, value: V)
    -> Json;

    /// The `jsonb_object()` SQL function works just like the [`json_object()`](json_object_1())
    /// function except that the generated object is returned in SQLite's private binary JSONB
    /// format rather than in the standard RFC 8259 text format.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// # Examples
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::{Text, Integer};
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    /// #
    /// let result = diesel::select(jsonb_object_0()).get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({}), result);
    ///
    /// let result = diesel::select(jsonb_object_1::<Text, Integer, _, _>("a", 2))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 2}), result);
    ///
    /// let result = diesel::select(
    ///     jsonb_object_2::<Text, Integer, Text, Text, _, _, _, _>("a", 2, "c", "{e:5}")
    /// )
    /// .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 2, "c": "{e:5}"}), result);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[variadic(2)]
    fn jsonb_object<K: NotBlob<IsNull = is_nullable::NotNull>, V: NotBlob>(
        key: K,
        value: V,
    ) -> Jsonb;

    /// The json_group_object(NAME,VALUE) function returns a JSON object comprised of all NAME/VALUE pairs in
    /// the aggregation.
    ///
    /// A potential edge case in this function arises when `names` contains duplicate elements.
    /// In such case, the result will include all duplicates (e.g., `{"key": 1, "key": 2, "key": 3}`).
    /// Note that any duplicate entries in the resulting JSON will be removed during deserialization.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// ## Aggregate Function Expression
    ///
    /// This function can be used as aggregate expression. See [`AggregateExpressionMethods`] for details.
    ///
    /// # Examples
    ///
    /// ## Normal function usage
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::Text;
    /// #     use serde_json::json;
    /// #     use schema::animals::dsl::*;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    /// #
    /// let result = animals.select(json_group_object(species, name)).get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"dog":"Jack","spider":null}), result);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    ///
    /// ## Aggregate function expression
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::Text;
    /// #     use serde_json::json;
    /// #     use schema::animals::dsl::*;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #
    /// #     let version = diesel::select(sql::<Text>("sqlite_version();"))
    /// #         .get_result::<String>(connection)?;
    /// #
    /// #     let version_components: Vec<&str> = version.split('.').collect();
    /// #     let major: u32 = version_components[0].parse().unwrap();
    /// #     let minor: u32 = version_components[1].parse().unwrap();
    /// #
    /// #     if major < 3 || minor < 38 {
    /// #         println!("SQLite version is too old, skipping the test.");
    /// #         return Ok(());
    /// #     }
    /// #
    /// let result = animals.select(json_group_object(species, name).aggregate_filter(legs.lt(8))).get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"dog":"Jack"}), result);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    ///
    /// # See also
    /// - [`jsonb_group_object`](jsonb_group_object()) will return data in JSONB format instead of JSON.
    /// - [`json_group_array`](json_group_array()) will return JSON array instead of object.
    #[cfg(feature = "__sqlite-shared")]
    #[aggregate]
    fn json_group_object<
        N: SqlType<IsNull = is_nullable::NotNull> + SingleValue,
        V: SqlType + SingleValue,
    >(
        names: N,
        values: V,
    ) -> Json;

    /// The jsonb_group_object(NAME,VALUE) function returns a JSONB object comprised of all NAME/VALUE pairs in
    /// the aggregation.
    ///
    /// A potential edge case in this function arises when `names` contains duplicate elements.
    /// In such case, the result will include all duplicates (e.g., `{"key": 1, "key": 2, "key": 3}`).
    /// Note that any duplicate entries in the resulting JSONB will be removed during deserialization.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// ## Aggregate Function Expression
    ///
    /// This function can be used as aggregate expression. See [`AggregateExpressionMethods`] for details.
    ///
    /// # Examples
    ///
    /// ## Normal function usage
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::Text;
    /// #     use serde_json::json;
    /// #     use schema::animals::dsl::*;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    /// #
    /// let result = animals.select(jsonb_group_object(species, name)).get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"dog":"Jack","spider":null}), result);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    ///
    /// ## Aggregate function expression
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::Text;
    /// #     use serde_json::json;
    /// #     use schema::animals::dsl::*;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #
    /// #     let version = diesel::select(sql::<Text>("sqlite_version();"))
    /// #         .get_result::<String>(connection)?;
    /// #
    /// #     let version_components: Vec<&str> = version.split('.').collect();
    /// #     let major: u32 = version_components[0].parse().unwrap();
    /// #     let minor: u32 = version_components[1].parse().unwrap();
    /// #
    /// #     if major < 3 || minor < 38 {
    /// #         println!("SQLite version is too old, skipping the test.");
    /// #         return Ok(());
    /// #     }
    /// #
    /// let result = animals.select(jsonb_group_object(species, name).aggregate_filter(legs.lt(8))).get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"dog":"Jack"}), result);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    ///
    /// # See also
    /// - [`json_group_object`](jsonb_group_array()) will return data in JSON format instead of JSONB.
    /// - [`jsonb_group_array`](jsonb_group_array()) will return JSONB array instead of object.
    #[cfg(feature = "__sqlite-shared")]
    #[aggregate]
    fn jsonb_group_object<
        N: SqlType<IsNull = is_nullable::NotNull> + SingleValue,
        V: SqlType + SingleValue,
    >(
        names: N,
        values: V,
    ) -> Jsonb;

    /// The `json_array()` SQL function accepts zero or more arguments and returns a well-formed JSON array
    /// that is composed from those arguments. Note that arguments of type BLOB will not be accepted by this
    /// function.
    ///
    /// An argument with SQL type TEXT is normally converted into a quoted JSON string. However, if the
    /// argument is the output from another json function, then it is stored as JSON. This allows calls to
    /// `json_array()` and `json_object()` to be nested. The [`json()`] function can also be used to force
    /// strings to be recognized as JSON.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// # Examples
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::{Text, Double};
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    /// #
    /// let result = diesel::select(json_array_0()).get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!([]), result);
    ///
    /// let result = diesel::select(json_array_1::<Text, _>("abc"))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!(["abc"]), result);
    ///
    /// let result = diesel::select(json_array_2::<Text, Double, _, _>("abc", 3.1415))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!(["abc", 3.1415]), result);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[variadic(1)]
    fn json_array<V: NotBlob>(value: V) -> Json;

    /// The `jsonb_array()` SQL function accepts zero or more arguments and returns a well-formed JSON array
    /// that is composed from those arguments. Note that arguments of type BLOB will not be accepted by this
    /// function.
    ///
    /// An argument with SQL type TEXT is normally converted into a quoted JSON string. However, if the
    /// argument is the output from another json function, then it is stored as JSON. This allows calls to
    /// `jsonb_array()` and `jsonb_object()` to be nested. The [`json()`] function can also be used to force
    /// strings to be recognized as JSON.
    ///
    /// This function works just like the [`json_array()`](json_array_1()) function except that it returns the
    /// constructed JSON array in the SQLite's private JSONB format rather than in the standard RFC 8259 text
    /// format.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// # Examples
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::{Text, Double};
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    /// #
    /// let result = diesel::select(jsonb_array_0()).get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!([]), result);
    ///
    /// let result = diesel::select(jsonb_array_1::<Text, _>("abc"))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!(["abc"]), result);
    ///
    /// let result = diesel::select(jsonb_array_2::<Text, Double, _, _>("abc", 3.1415))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!(["abc", 3.1415]), result);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[variadic(1)]
    fn jsonb_array<V: NotBlob>(value: V) -> Jsonb;

    /// The `json_remove(X,P,...)` SQL function takes a single JSON value as its first argument followed by
    /// zero or more path arguments. The `json_remove(X,P,...)` function returns a copy of the X parameter
    /// with all the elements identified by path arguments removed. Paths that select elements not found in X
    /// are silently ignored.
    ///
    /// Removals occurs sequentially from left to right. Changes caused by prior removals can affect the path
    /// search for subsequent arguments.
    ///
    /// If the `json_remove(X)` function is called with no path arguments, then it returns the input X
    /// reformatted, with excess whitespace removed.
    ///
    /// The `json_remove()` function throws an error if any of the path arguments is not a well-formed path.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// # Examples
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::{Json, Text};
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    /// #
    /// let json = json!(['a', 'b', 'c', 'd']);
    /// let result = diesel::select(json_remove_0::<Json, _>(json))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(Some(json!(['a', 'b', 'c', 'd'])), result);
    ///
    /// // Values are removed sequentially from left to right.
    /// let json = json!(['a', 'b', 'c', 'd']);
    /// let result = diesel::select(json_remove_2::<Json, _, _, _>(json, "$[0]", "$[2]"))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(Some(json!(['b', 'c'])), result);
    ///
    /// let json = json!({"a": 10, "b": 20});
    /// let result = diesel::select(json_remove_1::<Json, _, _>(json, "$.a"))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(Some(json!({"b": 20})), result);
    ///
    /// // Paths that select not existing elements are silently ignored.
    /// let json = json!({"a": 10, "b": 20});
    /// let result = diesel::select(json_remove_1::<Json, _, _>(json, "$.c"))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(Some(json!({"a": 10, "b": 20})), result);
    ///
    /// let json = json!({"a": 10, "b": 20});
    /// let result = diesel::select(json_remove_1::<Json, _, _>(json, "$"))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(None, result);
    ///
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[variadic(1)]
    fn json_remove<J: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue>(
        json: J,
        path: Text,
    ) -> Nullable<Json>;

    /// The `jsonb_remove(X,P,...)` SQL function takes a single JSON value as its first argument followed by
    /// zero or more path arguments. The `jsonb_remove(X,P,...)` function returns a copy of the X parameter
    /// with all the elements identified by path arguments removed. Paths that select elements not found in X
    /// are silently ignored.
    ///
    /// Removals occurs sequentially from left to right. Changes caused by prior removals can affect the path
    /// search for subsequent arguments.
    ///
    /// If the `jsonb_remove(X)` function is called with no path arguments, then it returns the input X
    /// reformatted, with excess whitespace removed.
    ///
    /// The `jsonb_remove()` function throws an error if any of the path arguments is not a well-formed path.
    ///
    /// This function returns value in a binary JSONB format.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// # Examples
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::{Jsonb, Text};
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    /// #
    /// let json = json!(['a', 'b', 'c', 'd']);
    /// let result = diesel::select(jsonb_remove_0::<Jsonb, _>(json))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(Some(json!(['a', 'b', 'c', 'd'])), result);
    ///
    /// // Values are removed sequentially from left to right.
    /// let json = json!(['a', 'b', 'c', 'd']);
    /// let result = diesel::select(jsonb_remove_2::<Jsonb, _, _, _>(json, "$[0]", "$[2]"))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(Some(json!(['b', 'c'])), result);
    ///
    /// let json = json!({"a": 10, "b": 20});
    /// let result = diesel::select(jsonb_remove_1::<Jsonb, _, _>(json, "$.a"))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(Some(json!({"b": 20})), result);
    ///
    /// // Paths that select not existing elements are silently ignored.
    /// let json = json!({"a": 10, "b": 20});
    /// let result = diesel::select(jsonb_remove_1::<Jsonb, _, _>(json, "$.c"))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(Some(json!({"a": 10, "b": 20})), result);
    ///
    /// let json = json!({"a": 10, "b": 20});
    /// let result = diesel::select(jsonb_remove_1::<Jsonb, _, _>(json, "$"))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(None, result);
    ///
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[variadic(1)]
    fn jsonb_remove<J: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue>(
        json: J,
        path: Text,
    ) -> Nullable<Jsonb>;

    /// The `json_insert(X,P,V,...)` SQL function takes a single JSON value as its first argument
    /// followed by zero or more pairs of path and value arguments. It returns a copy of the X
    /// argument with the values V inserted at the paths P, but only where nothing already exists at
    /// the path. Paths that already select an element of X are left unchanged.
    ///
    /// The path/value pairs are applied sequentially from left to right.
    ///
    /// A path that ends in `[#]` appends the value to an existing array.
    ///
    /// If the `json_insert(X)` function is called with no path/value pairs, then it returns the
    /// input X reformatted, with excess whitespace removed.
    ///
    /// The `json_insert()` function throws an error if any of the path arguments is not a
    /// well-formed path.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// # Examples
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::{Integer, Json, Text, Nullable};
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    /// #
    /// let json = json!({"a": 1, "c": 3});
    /// let result = diesel::select(json_insert_1::<Json, Integer, _, _, _>(json, "$.b", 2))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1, "b": 2, "c": 3}), result);
    ///
    /// // A path that already exists is left unchanged.
    /// let json = json!({"a": 1});
    /// let result = diesel::select(json_insert_1::<Json, Integer, _, _, _>(json, "$.a", 99))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1}), result);
    ///
    /// // A path ending in "[#]" appends to an array.
    /// let json = json!(['a', 'b', 'c']);
    /// let result = diesel::select(json_insert_1::<Json, Text, _, _, _>(json, "$[#]", "d"))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!(['a', 'b', 'c', 'd']), result);
    ///
    /// let json = json!({"a": 1});
    /// let result = diesel::select(
    ///     json_insert_2::<Json, Integer, Integer, _, _, _, _, _>(json, "$.b", 2, "$.c", 3),
    /// )
    /// .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1, "b": 2, "c": 3}), result);
    ///
    /// let json = json!({"a": 1});
    /// let result = diesel::select(json_insert_0::<Json, _>(json))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1}), result);
    ///
    /// let result = diesel::select(json_insert_1::<Nullable<Json>, Integer, _, _, _>(None::<serde_json::Value>, "$.b", 1))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(result, None);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[variadic(2)]
    fn json_insert<
        J: JsonOrNullableJsonOrJsonbOrNullableJsonb + MaybeNullableValue<Json> + SingleValue,
        V: NotBlob,
    >(
        json: J,
        path: Text,
        value: V,
    ) -> J::Out;

    /// The `jsonb_insert(X,P,V,...)` SQL function works just like the [`json_insert()`](json_insert_1())
    /// function except that the result is returned in SQLite's private binary JSONB format rather than
    /// in the standard RFC 8259 text format.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// # Examples
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::{Integer, Jsonb, Text, Nullable};
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    /// #
    /// let json = json!({"a": 1, "c": 3});
    /// let result = diesel::select(jsonb_insert_1::<Jsonb, Integer, _, _, _>(json, "$.b", 2))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1, "b": 2, "c": 3}), result);
    ///
    /// // A path that already exists is left unchanged.
    /// let json = json!({"a": 1});
    /// let result = diesel::select(jsonb_insert_1::<Jsonb, Integer, _, _, _>(json, "$.a", 99))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1}), result);
    ///
    /// // A path ending in "[#]" appends to an array.
    /// let json = json!(['a', 'b', 'c']);
    /// let result = diesel::select(jsonb_insert_1::<Jsonb, Text, _, _, _>(json, "$[#]", "d"))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!(['a', 'b', 'c', 'd']), result);
    ///
    /// let json = json!({"a": 1});
    /// let result = diesel::select(
    ///     jsonb_insert_2::<Jsonb, Integer, Integer, _, _, _, _, _>(json, "$.b", 2, "$.c", 3),
    /// )
    /// .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1, "b": 2, "c": 3}), result);
    ///
    /// let json = json!({"a": 1});
    /// let result = diesel::select(jsonb_insert_0::<Jsonb, _>(json))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1}), result);
    ///
    /// let result = diesel::select(jsonb_insert_1::<Nullable<Jsonb>, Integer, _, _, _>(None::<serde_json::Value>, "$.b", 1))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(result, None);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[variadic(2)]
    fn jsonb_insert<
        J: JsonOrNullableJsonOrJsonbOrNullableJsonb + MaybeNullableValue<Jsonb> + SingleValue,
        V: NotBlob,
    >(
        json: J,
        path: Text,
        value: V,
    ) -> J::Out;

    /// The `json_replace(X,P,V,...)` SQL function takes a single JSON value as its first argument
    /// followed by zero or more pairs of path and value arguments. It returns a copy of the X
    /// argument with values V substituted at the paths P, but only where something already exists
    /// at the path. Paths that select elements not found in X are silently ignored.
    ///
    /// The path/value pairs are applied sequentially from left to right.
    ///
    /// If the `json_replace(X)` function is called with no path/value pairs, then it returns the
    /// input X reformatted, with excess whitespace removed.
    ///
    /// The `json_replace()` function throws an error if any of the path arguments is not a
    /// well-formed path.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// # Examples
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::{Integer, Json, Text, Nullable};
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    /// #
    /// let json = json!({"a": 1, "b": 2});
    /// let result = diesel::select(json_replace_1::<Json, Integer, _, _, _>(json, "$.a", 99))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 99, "b": 2}), result);
    ///
    /// // A path that does not exist is silently ignored.
    /// let json = json!({"a": 1});
    /// let result = diesel::select(json_replace_1::<Json, Integer, _, _, _>(json, "$.b", 2))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1}), result);
    ///
    /// let json = json!({"a": 1, "b": 2});
    /// let result = diesel::select(
    ///     json_replace_2::<Json, Integer, Text, _, _, _, _, _>(json, "$.a", 99, "$.b", "x"),
    /// )
    /// .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 99, "b": "x"}), result);
    ///
    /// let json = json!({"a": 1});
    /// let result = diesel::select(json_replace_0::<Json, _>(json))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1}), result);
    ///
    /// let result = diesel::select(json_replace_1::<Nullable<Json>, Integer, _, _, _>(None::<serde_json::Value>, "$.a", 1))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(result, None);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[variadic(2)]
    fn json_replace<
        J: JsonOrNullableJsonOrJsonbOrNullableJsonb + MaybeNullableValue<Json> + SingleValue,
        V: NotBlob,
    >(
        json: J,
        path: Text,
        value: V,
    ) -> J::Out;

    /// The `jsonb_replace(X,P,V,...)` SQL function works just like the [`json_replace()`](json_replace_1())
    /// function except that the result is returned in SQLite's private binary JSONB format rather than
    /// in the standard RFC 8259 text format.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// # Examples
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::{Integer, Jsonb, Text, Nullable};
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    /// #
    /// let json = json!({"a": 1, "b": 2});
    /// let result = diesel::select(jsonb_replace_1::<Jsonb, Integer, _, _, _>(json, "$.a", 99))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 99, "b": 2}), result);
    ///
    /// // A path that does not exist is silently ignored.
    /// let json = json!({"a": 1});
    /// let result = diesel::select(jsonb_replace_1::<Jsonb, Integer, _, _, _>(json, "$.b", 2))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1}), result);
    ///
    /// let json = json!({"a": 1});
    /// let result = diesel::select(jsonb_replace_0::<Jsonb, _>(json))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1}), result);
    ///
    /// let result = diesel::select(jsonb_replace_1::<Nullable<Jsonb>, Integer, _, _, _>(None::<serde_json::Value>, "$.a", 1))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(result, None);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[variadic(2)]
    fn jsonb_replace<
        J: JsonOrNullableJsonOrJsonbOrNullableJsonb + MaybeNullableValue<Jsonb> + SingleValue,
        V: NotBlob,
    >(
        json: J,
        path: Text,
        value: V,
    ) -> J::Out;

    /// The `json_set(X,P,V,...)` SQL function takes a single JSON value as its first argument
    /// followed by zero or more pairs of path and value arguments. It returns a copy of the X
    /// argument with values V inserted or replaced at the paths P. Unlike [`json_replace()`](json_replace_1()),
    /// `json_set()` also inserts new values where the path does not already exist.
    ///
    /// The path/value pairs are applied sequentially from left to right.
    ///
    /// A path that ends in `[#]` appends the value to an existing array.
    ///
    /// If the `json_set(X)` function is called with no path/value pairs, then it returns the
    /// input X reformatted, with excess whitespace removed.
    ///
    /// The `json_set()` function throws an error if any of the path arguments is not a
    /// well-formed path.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// # Examples
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::{Integer, Json, Text, Nullable};
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    /// #
    /// let json = json!({"a": 1});
    /// let result = diesel::select(json_set_1::<Json, Integer, _, _, _>(json, "$.b", 2))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1, "b": 2}), result);
    ///
    /// // Existing values are replaced.
    /// let json = json!({"a": 1});
    /// let result = diesel::select(json_set_1::<Json, Integer, _, _, _>(json, "$.a", 99))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 99}), result);
    ///
    /// // A path ending in "[#]" appends to an array.
    /// let json = json!(['a', 'b', 'c']);
    /// let result = diesel::select(json_set_1::<Json, Text, _, _, _>(json, "$[#]", "d"))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!(['a', 'b', 'c', 'd']), result);
    ///
    /// let json = json!({"a": 1});
    /// let result = diesel::select(
    ///     json_set_2::<Json, Integer, Integer, _, _, _, _, _>(json, "$.b", 2, "$.c", 3),
    /// )
    /// .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1, "b": 2, "c": 3}), result);
    ///
    /// let json = json!({"a": 1});
    /// let result = diesel::select(json_set_0::<Json, _>(json))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1}), result);
    ///
    /// let result = diesel::select(json_set_1::<Nullable<Json>, Integer, _, _, _>(None::<serde_json::Value>, "$.b", 1))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(result, None);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[variadic(2)]
    fn json_set<
        J: JsonOrNullableJsonOrJsonbOrNullableJsonb + MaybeNullableValue<Json> + SingleValue,
        V: NotBlob,
    >(
        json: J,
        path: Text,
        value: V,
    ) -> J::Out;

    /// The `jsonb_set(X,P,V,...)` SQL function works just like the [`json_set()`](json_set_1())
    /// function except that the result is returned in SQLite's private binary JSONB format rather than
    /// in the standard RFC 8259 text format.
    ///
    /// This function requires at least SQLite 3.38 or newer
    ///
    /// # Examples
    ///
    /// ```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::*;
    /// #     use diesel::sql_types::{Integer, Jsonb, Text, Nullable};
    /// #     use serde_json::json;
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 38, 0);
    /// #
    /// let json = json!({"a": 1});
    /// let result = diesel::select(jsonb_set_1::<Jsonb, Integer, _, _, _>(json, "$.b", 2))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1, "b": 2}), result);
    ///
    /// // Existing values are replaced.
    /// let json = json!({"a": 1});
    /// let result = diesel::select(jsonb_set_1::<Jsonb, Integer, _, _, _>(json, "$.a", 99))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 99}), result);
    ///
    /// // A path ending in "[#]" appends to an array.
    /// let json = json!(['a', 'b', 'c']);
    /// let result = diesel::select(jsonb_set_1::<Jsonb, Text, _, _, _>(json, "$[#]", "d"))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!(['a', 'b', 'c', 'd']), result);
    ///
    /// let json = json!({"a": 1});
    /// let result = diesel::select(jsonb_set_0::<Jsonb, _>(json))
    ///     .get_result::<serde_json::Value>(connection)?;
    /// assert_eq!(json!({"a": 1}), result);
    ///
    /// let result = diesel::select(jsonb_set_1::<Nullable<Jsonb>, Integer, _, _, _>(None::<serde_json::Value>, "$.b", 1))
    ///     .get_result::<Option<serde_json::Value>>(connection)?;
    /// assert_eq!(result, None);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    #[variadic(2)]
    fn jsonb_set<
        J: JsonOrNullableJsonOrJsonbOrNullableJsonb + MaybeNullableValue<Jsonb> + SingleValue,
        V: NotBlob,
    >(
        json: J,
        path: Text,
        value: V,
    ) -> J::Out;

    /// Applies an RFC 7396 MergePatch `patch` to the input JSON `target` and
    /// returns the patched JSON value.
    ///
    /// MergePatch can add, modify, or delete elements of a JSON object. Arrays are
    /// treated as atomic values: they can only be inserted, replaced, or deleted as a
    /// whole, not modified element-wise.
    ///
    /// # Examples
    ///
    /// ```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_patch;
    /// #     use serde_json::{json, Value};
    /// #     use diesel::sql_types::{Json, Nullable};
    /// #     let connection = &mut establish_connection();
    ///
    /// let result = diesel::select(json_patch::<Json, Json, _, _>(
    ///     json!( {"a":1,"b":2} ),
    ///     json!( {"c":3,"d":4} ),
    /// ))
    /// .get_result::<Value>(connection)?;
    /// assert_eq!(json!({"a":1,"b":2,"c":3,"d":4}), result);
    ///
    /// let result = diesel::select(json_patch::<Json, Json, _, _>(
    ///     json!( {"a":[1,2],"b":2} ),
    ///     json!( {"a":9} ),
    /// ))
    /// .get_result::<Value>(connection)?;
    /// assert_eq!(json!({"a":9,"b":2}), result);
    ///
    /// let result = diesel::select(json_patch::<Json, Json, _, _>(
    ///     json!( {"a":[1,2],"b":2} ),
    ///     json!( {"a":null} ),
    /// ))
    /// .get_result::<Value>(connection)?;
    /// assert_eq!(json!({"b":2}), result);
    ///
    /// let result = diesel::select(json_patch::<Json, Json, _, _>(
    ///     json!( {"a":1,"b":2} ),
    ///     json!( {"a":9,"b":null,"c":8} ),
    /// ))
    /// .get_result::<Value>(connection)?;
    /// assert_eq!(json!({"a":9,"c":8}), result);
    ///
    /// let result = diesel::select(json_patch::<Json, Json, _, _>(
    ///     json!( {"a":{"x":1,"y":2},"b":3} ),
    ///     json!( {"a":{"y":9},"c":8} ),
    /// ))
    /// .get_result::<Value>(connection)?;
    /// assert_eq!(
    ///     json!({"a":{"x":1,"y":9},"b":3,"c":8}),
    ///     result
    /// );
    ///
    /// // Nullable input yields nullable output
    /// let result = diesel::select(json_patch::<Nullable<Json>, Json, _, _>(
    ///     None::<Value>,
    ///     json!({}),
    /// ))
    /// .get_result::<Option<Value>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// #     Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    fn json_patch<
        T: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue,
        P: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue + CombinedNullableValue<T, Json>,
    >(
        target: T,
        patch: P,
    ) -> P::Out;

    /// Applies an RFC 7396 MergePatch `patch` to the input JSON `target` and
    /// returns the patched JSON value in SQLite's binary JSONB format.
    ///
    /// See [`json_patch`](json_patch()) for details about the MergePatch semantics.
    ///
    /// # Examples
    ///
    /// ```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_patch;
    /// #     use serde_json::{json, Value};
    /// #     use diesel::sql_types::{Jsonb, Nullable};
    /// #     let connection = &mut establish_connection();
    /// #     assert_version!(connection, 3, 45, 0);
    ///
    /// let result = diesel::select(jsonb_patch::<Jsonb, Jsonb, _, _>(
    ///     json!( {"a":1,"b":2} ),
    ///     json!( {"c":3,"d":4} ),
    /// ))
    /// .get_result::<Value>(connection)?;
    /// assert_eq!(json!({"a":1,"b":2,"c":3,"d":4}), result);
    ///
    /// // Nullable input yields nullable output
    /// let result = diesel::select(jsonb_patch::<Nullable<Jsonb>, Jsonb, _, _>(
    ///     None::<Value>,
    ///     json!({}),
    /// ))
    /// .get_result::<Option<Value>>(connection)?;
    /// assert!(result.is_none());
    ///
    /// #     Ok(())
    /// # }
    /// ```
    #[cfg(feature = "__sqlite-shared")]
    fn jsonb_patch<
        T: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue,
        P: JsonOrNullableJsonOrJsonbOrNullableJsonb + SingleValue + CombinedNullableValue<T, Jsonb>,
    >(
        target: T,
        patch: P,
    ) -> P::Out;
}

pub(super) mod return_type_helpers_reexported {
    #[allow(unused_imports)]
    #[doc(inline)]
    pub use super::return_type_helpers::*;
}