implement jsonb_path_exists

Author: valkrypton

diesel/src/pg/expression/functions.rs

@@ -2301,11 +2301,11 @@ define_sql_function! {
     /// #     use jsonpath_rust::JsonPath;
     /// #     let connection = &mut establish_connection();
     /// let jsonb:Value = serde_json::json!({"a":[1,2,3,4,5]});
-    /// let json_path = jsonpath_rust::path!("$.a[*] ? (@ >= 2 && @ <= 4)");
-    /// let exists = jsonb_path_exists::<Jsonb,Jsonpath,_,_>(jsonb,json_path);
+    /// let json_path = jsonpath_rust::path!("$.a[ ? (@ >= 2 && @ <= 4)]");
+    /// let exists = jsonb_path_exists::<Jsonb,Jsonpath,_,_>(jsonb,json_path).get_result::<bool>(connection)?;
     /// assert!(exists);
     /// #     Ok(())
     /// # }
     /// ```
-    fn jsonb_path_exists<J: JsonbOrNullableJsonb + SingleValue,P:MaybeNullableValue<Jsonpath>>(jsonb:J,path:P)->Bool;
-}
+    fn jsonb_path_exists<J: JsonbOrNullableJsonb + SingleValue, P: MaybeNullableValue<Jsonpath>>(jsonb: J, path: P) -> Bool;
+}

diesel/src/pg/types/json_path.rs

@@ -1,13 +1,13 @@
-use crate::deserialize::FromSql;
-use crate::pg::{backend::Pg, PgValue};
-use crate::serialize::{IsNull, Output, ToSql};
-use crate::{deserialize, serialize, sql_types};
 use std::error::Error;
-use std::fmt::{Debug, Display};
 use std::io::Write;
 use std::str;
 use std::str::FromStr;
 
+use crate::{deserialize, serialize, sql_types};
+use crate::deserialize::FromSql;
+use crate::pg::{backend::Pg, PgValue};
+use crate::serialize::{IsNull, Output, ToSql};
+
 impl FromSql<sql_types::Jsonpath, Pg> for jsonpath_rust::JsonPath {
     fn from_sql(value: PgValue<'_>) -> deserialize::Result<Self> {
         println!("{:?}", value.as_bytes());
@@ -29,18 +29,19 @@ impl ToSql<sql_types::Jsonpath, Pg> for jsonpath_rust::JsonPath {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use jsonpath_rust::JsonPath;
+
     use crate::pg::PgValue;
     use crate::query_builder::bind_collector::ByteWrapper;
-    use jsonpath_rust::{path, JsonPath};
+
+    use super::*;
 
     #[test]
     fn json_to_sql() {
         let mut buffer = Vec::new();
         let mut bytes = Output::test(ByteWrapper(&mut buffer));
         let test_json_path = JsonPath::from_str("$.a[?(@ >= 2 && @ <= 4)]").unwrap();
         ToSql::<sql_types::Jsonpath, Pg>::to_sql(&test_json_path, &mut bytes).unwrap();
-        println!("{}",String::from_utf8(buffer.clone()).unwrap());
         assert_eq!(buffer, b"$.'a'[?(@ >= 2 && @ <= 4)]");
     }
 

diesel/src/pg/types/mod.rs

@@ -10,6 +10,7 @@ mod integers;
 mod ipnet_address;
 #[cfg(feature = "serde_json")]
 mod json;
+mod json_path;
 mod mac_addr;
 mod mac_addr_8;
 #[doc(hidden)]
@@ -23,7 +24,6 @@ mod ranges;
 mod record;
 #[cfg(feature = "uuid")]
 mod uuid;
-mod json_path;
 
 /// PostgreSQL specific SQL types
 ///
@@ -646,11 +646,10 @@ pub mod sql_types {
     #[diesel(postgres_type(name = "citext"))]
     pub struct Citext;
 
-
     /// The [`Jsonpath`] SQL type. This is a PostgreSQL specific type.
     #[cfg(feature = "postgres_backend")]
     #[derive(Debug, Clone, Copy, Default, QueryId, SqlType)]
-    #[diesel(postgres_type(name = "jsonpath"))]
+    #[diesel(postgres_type(oid = 4072, array_oid = 4073))]
     pub struct Jsonpath;
 }
 

diesel/src/type_impls/json.rs

@@ -5,9 +5,16 @@ use crate::expression::AsExpression;
 use crate::sql_types::Json;
 #[cfg(any(feature = "postgres_backend", feature = "sqlite"))]
 use crate::sql_types::Jsonb;
+use crate::sql_types::Jsonpath;
 
 #[derive(AsExpression, FromSqlRow)]
 #[diesel(foreign_derive)]
 #[diesel(sql_type = Json)]
 #[cfg_attr(any(feature = "postgres_backend", feature = "sqlite"), diesel(sql_type = Jsonb))]
 struct SerdeJsonValueProxy(serde_json::Value);
+
+
+#[derive(AsExpression, FromSqlRow)]
+#[diesel(foreign_derive)]
+#[cfg_attr(any(feature = "postgres_backend"), diesel(sql_type = Jsonpath))]
+struct JsonpathProxy(jsonpath_rust::JsonPath);