feat: add json support

src/models/ty.rs

@@ -154,6 +154,10 @@ mod tests {
         let ty = RawPrestoTy::Char;
         let s = serde_json::to_string(&ty).unwrap();
         assert_eq!(s, "\"char\"");
+
+        let ty = RawPrestoTy::Json;
+        let s = serde_json::to_string(&ty).unwrap();
+        assert_eq!(s, "\"json\"");
     }
 
     #[test]
@@ -162,6 +166,10 @@ mod tests {
         let ty = serde_json::from_str::<RawPrestoTy>(data).unwrap();
         assert_eq!(ty, RawPrestoTy::Char);
 
+        let data = "\"json\"";
+        let ty = serde_json::from_str::<RawPrestoTy>(data).unwrap();
+        assert_eq!(ty, RawPrestoTy::Json);
+
         let invalid = "\"xxx\"";
         let res = serde_json::from_str::<RawPrestoTy>(invalid);
         assert!(res.is_err());

src/types/json.rs

@@ -0,0 +1,37 @@
+use crate::{Context, Presto, PrestoTy};
+use serde::de::DeserializeSeed;
+use serde::{Deserialize, Deserializer};
+use serde_json::Value;
+
+impl Presto for Value {
+    type ValueType<'a> = &'a Value;
+    type Seed<'a, 'de> = ValueSeed;
+
+    fn value(&self) -> Self::ValueType<'_> {
+        self
+    }
+
+    fn ty() -> PrestoTy {
+        PrestoTy::Json
+    }
+
+    fn seed<'a, 'de>(ctx: &'a Context<'a>) -> Self::Seed<'a, 'de> {
+        ValueSeed
+    }
+
+    fn empty() -> Self {
+        Value::empty()
+    }
+}
+
+pub struct ValueSeed;
+
+impl<'de> DeserializeSeed<'de> for ValueSeed {
+    type Value = Value;
+    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        <Value as Deserialize<'de>>::deserialize(deserializer)
+    }
+}

src/types/mod.rs

@@ -8,6 +8,7 @@ mod integer;
 mod interval_day_to_second;
 mod interval_year_to_month;
 mod ip_address;
+pub mod json;
 mod map;
 mod option;
 mod row;
@@ -43,9 +44,10 @@ use std::sync::Arc;
 
 use derive_more::Display;
 use iterable::*;
-use serde::de::DeserializeSeed;
+use serde::de::{DeserializeSeed, IntoDeserializer};
 use serde::Serialize;
 
+use crate::PrestoTy::Uuid;
 use crate::{
     ClientTypeSignatureParameter, Column, NamedTypeSignature, RawPrestoTy, RowFieldName,
     TypeSignature,
@@ -165,6 +167,7 @@ fn extract(target: &PrestoTy, provided: &PrestoTy) -> Result<Vec<(usize, Vec<usi
         (Map(t1k, t1v), Map(t2k, t2v)) => Ok(extract(t1k, t2k)?.chain(extract(t1v, t2v)?)),
         (IpAddress, IpAddress) => Ok(vec![]),
         (Uuid, Uuid) => Ok(vec![]),
+        (Json, Json) => Ok(vec![]),
         _ => Err(Error::InvalidPrestoType),
     }
 }
@@ -194,6 +197,7 @@ pub enum PrestoTy {
     Map(Box<PrestoTy>, Box<PrestoTy>),
     Decimal(usize, usize),
     IpAddress,
+    Json,
     Unknown,
 }
 
@@ -303,6 +307,7 @@ impl PrestoTy {
             }
             RawPrestoTy::IpAddress => PrestoTy::IpAddress,
             RawPrestoTy::Uuid => PrestoTy::Uuid,
+            RawPrestoTy::Json => PrestoTy::Json,
             _ => return Err(Error::InvalidTypeSignature),
         };
 
@@ -367,6 +372,7 @@ impl PrestoTy {
             ],
             IpAddress => vec![],
             Uuid => vec![],
+            Json => vec![],
         };
 
         TypeSignature::new(raw_ty, params)
@@ -412,6 +418,7 @@ impl PrestoTy {
             .into(),
             IpAddress => RawPrestoTy::IpAddress.to_str().into(),
             Uuid => RawPrestoTy::Uuid.to_str().into(),
+            Json => RawPrestoTy::Json.to_str().into(),
         }
     }
 
@@ -438,6 +445,7 @@ impl PrestoTy {
             Map(_, _) => RawPrestoTy::Map,
             IpAddress => RawPrestoTy::IpAddress,
             Uuid => RawPrestoTy::Uuid,
+            Json => RawPrestoTy::Json,
         }
     }
 }

tests/data/types/json

@@ -0,0 +1,19 @@
+{
+    "columns": [
+        {
+            "name": "a",
+            "type": "json",
+            "typeSignature": {
+                "rawType": "json",
+                "typeArguments": [],
+                "literalArguments": [],
+                "arguments": []
+            }
+        }
+    ],
+    "data": [
+        [
+            "abc"
+        ]
+    ]
+}

tests/data_set.rs

@@ -51,6 +51,19 @@ fn split(v: Value) -> Option<(Vec<Column>, Value)> {
     }
 }
 
+#[test]
+fn test_json() {
+    let (s, v) = read("json");
+    let d = serde_json::from_str::<DataSet<Row>>(&s).unwrap();
+    assert_ds(d.clone(), v);
+    let d = d.into_vec();
+    assert_eq!(d.len(), 1);
+    assert_eq!(
+        d[0].clone().into_json(),
+        vec![Value::String("abc".to_string())]
+    );
+}
+
 #[test]
 fn test_char() {
     #[derive(Presto, Eq, PartialEq, Debug, Clone)]