use super::*;
impl Value {
pub fn to_json_tagged(&self) -> serde_json::Value {
serde_json::to_value(self).unwrap_or(serde_json::Value::Null)
}
pub fn from_json_tagged(v: &serde_json::Value) -> crate::Result<Value> {
Self::from_json_tagged_at(v, 0)
}
fn from_json_tagged_at(v: &serde_json::Value, depth: u32) -> crate::Result<Value> {
fn malformed(expected: &str) -> crate::Error {
crate::Error::storage(format!("malformed tagged value: expected {expected}"))
}
fn too_deep() -> crate::Error {
crate::Error::storage(value_depth_exceeded("tagged value"))
}
let obj = v
.as_object()
.ok_or_else(|| crate::Error::storage("property JSON must be an object"))?;
let t = obj
.get("t")
.and_then(|x| x.as_str())
.ok_or_else(|| crate::Error::storage("missing type tag"))?;
Ok(match t {
"null" => Value::Null,
"bool" => Value::Bool(
obj.get("v")
.and_then(|x| x.as_bool())
.ok_or_else(|| malformed("\"bool\" with a boolean \"v\""))?,
),
"int" => Value::Int(
obj.get("v")
.and_then(|x| x.as_i64())
.ok_or_else(|| malformed("\"int\" with an integer \"v\""))?,
),
"float" => Value::Float(match obj.get("v") {
Some(serde_json::Value::String(s)) if s == "NaN" => f64::NAN,
Some(serde_json::Value::String(s)) if s == "Infinity" => f64::INFINITY,
Some(serde_json::Value::String(s)) if s == "-Infinity" => f64::NEG_INFINITY,
other => other
.and_then(|x| x.as_f64())
.ok_or_else(|| malformed("\"float\" with a number \"v\""))?,
}),
"string" => Value::String(
obj.get("v")
.and_then(|x| x.as_str())
.ok_or_else(|| malformed("\"string\" with a string \"v\""))?
.into(),
),
"uuid" => {
let s = obj
.get("v")
.and_then(|x| x.as_str())
.ok_or_else(|| malformed("\"uuid\" with a string \"v\""))?;
Value::Uuid(
uuid_parse(s)
.ok_or_else(|| malformed("\"uuid\" with a canonical hyphenated \"v\""))?,
)
}
"list" => {
let Some(next) = next_depth(depth) else {
return Err(too_deep());
};
let arr = obj
.get("v")
.and_then(|x| x.as_array())
.ok_or_else(|| malformed("\"list\" with an array \"v\""))?;
Value::List(
arr.iter()
.map(|x| Value::from_json_tagged_at(x, next))
.collect::<crate::Result<Vec<_>>>()?
.into(),
)
}
"map" => {
let Some(next) = next_depth(depth) else {
return Err(too_deep());
};
let mut map = BTreeMap::new();
let o = obj
.get("v")
.and_then(|x| x.as_object())
.ok_or_else(|| malformed("\"map\" with an object \"v\""))?;
for (k, val) in o {
map.insert(k.clone(), Value::from_json_tagged_at(val, next)?);
}
Value::Map(map.into())
}
"date" | "time" | "localtime" | "datetime" | "localdatetime" | "duration" => {
let s = obj
.get("v")
.and_then(|x| x.as_str())
.ok_or_else(|| crate::Error::storage("missing temporal value"))?;
Value::Temporal(crate::temporal::parse_iso(t, s)?)
}
"point" => {
let p = obj
.get("v")
.and_then(|x| x.as_object())
.ok_or_else(|| malformed("\"point\" with an object \"v\""))?;
Value::Point(PointValue {
srid: p
.get("srid")
.and_then(|x| x.as_i64())
.and_then(|x| i32::try_from(x).ok())
.ok_or_else(|| malformed("\"point\" with an integer \"srid\""))?,
x: p.get("x")
.and_then(|x| x.as_f64())
.ok_or_else(|| malformed("\"point\" with a number \"x\""))?,
y: p.get("y")
.and_then(|x| x.as_f64())
.ok_or_else(|| malformed("\"point\" with a number \"y\""))?,
z: p.get("z").and_then(|x| x.as_f64()),
})
}
"vector" => {
let Some(next) = next_depth(depth) else {
return Err(too_deep());
};
let coord = obj
.get("coord")
.and_then(|x| x.as_str())
.and_then(VectorCoordKind::from_canonical_name)
.ok_or_else(|| crate::Error::storage("invalid vector coordinate type"))?;
let xs = obj
.get("v")
.and_then(|x| x.as_array())
.ok_or_else(|| malformed("\"vector\" with an array \"v\""))?;
let values = xs
.iter()
.map(|x| Value::from_json_tagged_at(x, next))
.collect::<crate::Result<Vec<_>>>()?;
Value::Vector {
coord,
values: values.into(),
}
}
other => return Err(crate::Error::storage(format!("unknown type tag {other:?}"))),
})
}
pub fn to_json_plain(&self) -> serde_json::Value {
self.to_json_plain_at(0)
}
fn to_json_plain_at(&self, depth: u32) -> serde_json::Value {
use serde_json::json;
match self {
Value::Null => serde_json::Value::Null,
Value::Bool(b) => json!(b),
Value::Int(i) => json!(i),
Value::Float(f) => json!(f),
Value::String(s) => json!(&**s),
Value::Uuid(u) => json!(uuid_hyphenated(*u)),
Value::Bytes(b) => json!(&**b),
Value::List(xs) => {
let Some(next) = next_depth(depth) else {
return serde_json::Value::Null;
};
json!(xs
.iter()
.map(|v| v.to_json_plain_at(next))
.collect::<Vec<_>>())
}
Value::Map(m) => {
let Some(next) = next_depth(depth) else {
return serde_json::Value::Null;
};
map_to_json_plain(m.iter(), next)
}
Value::Node(n) => node_json(n, depth),
Value::Relationship(r) => rel_json(r, depth),
Value::Path(p) => {
if next_depth(depth).is_none() {
return serde_json::Value::Null;
}
json!({
"_type": "path",
"nodes": p.nodes.iter().map(|n| node_json(n, depth)).collect::<Vec<_>>(),
"relationships": p.rels.iter().map(|r| rel_json(r, depth)).collect::<Vec<_>>(),
})
}
Value::Temporal(t) => json!({
"_type": t.kind_name(),
"value": t.iso_string(),
}),
Value::Point(p) => json!({
"_type": "point", "srid": p.srid, "x": p.x, "y": p.y, "z": p.z
}),
Value::Vector { coord, values } => {
let Some(next) = next_depth(depth) else {
return serde_json::Value::Null;
};
json!({
"_type": "vector",
"coordinateType": coord.canonical_name(),
"values": values.iter().map(|v| v.to_json_plain_at(next)).collect::<Vec<_>>()
})
}
}
}
pub fn from_json_plain(v: &serde_json::Value) -> Value {
match v {
serde_json::Value::Null => Value::Null,
serde_json::Value::Bool(b) => Value::Bool(*b),
serde_json::Value::Number(n) => {
if let Some(i) = n.as_i64() {
Value::Int(i)
} else if let Some(f) = n.as_f64() {
Value::Float(f)
} else {
Value::Null
}
}
serde_json::Value::String(s) => Value::String(s.as_str().into()),
serde_json::Value::Array(a) => Value::List(
a.iter()
.map(Value::from_json_plain)
.collect::<Vec<_>>()
.into(),
),
serde_json::Value::Object(o) => {
match o.get("_type").and_then(|t| t.as_str()) {
Some("node") => {
return Value::Node(Arc::new(Node {
id: o.get("id").and_then(|x| x.as_i64()).unwrap_or(0),
labels: Arc::new(
o.get("labels")
.and_then(|x| x.as_array())
.map(|a| {
a.iter()
.filter_map(|x| x.as_str().map(|s| s.to_string()))
.collect::<Vec<_>>()
})
.unwrap_or_default(),
),
properties: match o.get("properties") {
Some(p) => match Value::from_json_plain(p) {
Value::Map(m) => PropertyMap::share(Arc::unwrap_or_clone(m)),
_ => PropertyMap::share(PropertyMap::new()),
},
None => PropertyMap::share(PropertyMap::new()),
},
}));
}
Some("point") => {
return Value::Point(PointValue {
srid: o
.get("srid")
.and_then(|x| x.as_i64())
.and_then(|x| i32::try_from(x).ok())
.unwrap_or(7203),
x: o.get("x").and_then(|x| x.as_f64()).unwrap_or(0.0),
y: o.get("y").and_then(|x| x.as_f64()).unwrap_or(0.0),
z: o.get("z").and_then(|x| x.as_f64()),
});
}
Some("vector") => {
if let Some(coord) = o
.get("coordinateType")
.and_then(|x| x.as_str())
.and_then(VectorCoordKind::from_canonical_name)
{
let values: Vec<Value> = o
.get("values")
.and_then(|x| x.as_array())
.map(|xs| xs.iter().map(Value::from_json_plain).collect())
.unwrap_or_default();
return Value::Vector {
coord,
values: values.into(),
};
}
}
_ => {}
}
let mut m = BTreeMap::new();
for (k, val) in o {
m.insert(k.clone(), Value::from_json_plain(val));
}
Value::Map(m.into())
}
}
}
pub fn from_json_scalars(v: &serde_json::Value) -> Value {
match v {
serde_json::Value::Null => Value::Null,
serde_json::Value::Bool(b) => Value::Bool(*b),
serde_json::Value::Number(n) => {
if let Some(i) = n.as_i64() {
Value::Int(i)
} else if let Some(f) = n.as_f64() {
Value::Float(f)
} else {
Value::Null
}
}
serde_json::Value::String(s) => Value::String(s.as_str().into()),
serde_json::Value::Array(a) => Value::List(
a.iter()
.map(Value::from_json_scalars)
.collect::<Vec<_>>()
.into(),
),
serde_json::Value::Object(o) => {
let mut m = BTreeMap::new();
for (k, val) in o {
m.insert(k.clone(), Value::from_json_scalars(val));
}
Value::Map(m.into())
}
}
}
}
pub struct TaggedStr<'a>(&'a str);
fn write_tagged_str<M: serde::ser::SerializeMap>(m: &mut M, s: &str) -> Result<(), M::Error> {
m.serialize_entry("t", "string")?;
m.serialize_entry("v", s)?;
Ok(())
}
impl serde::Serialize for TaggedStr<'_> {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeMap;
let mut m = serializer.serialize_map(Some(2))?;
write_tagged_str(&mut m, self.0)?;
m.end()
}
}
pub fn tagged_str(s: &str) -> TaggedStr<'_> {
TaggedStr(s)
}
struct TaggedRef<'a>(&'a Value);
impl serde::Serialize for TaggedRef<'_> {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeMap;
let mut m = serializer.serialize_map(Some(2))?;
match self.0 {
Value::Null => m.serialize_entry("t", "null")?,
Value::Bool(b) => {
m.serialize_entry("t", "bool")?;
m.serialize_entry("v", b)?;
}
Value::Int(i) => {
m.serialize_entry("t", "int")?;
m.serialize_entry("v", i)?;
}
Value::Float(f) => {
m.serialize_entry("t", "float")?;
if f.is_nan() {
m.serialize_entry("v", "NaN")?;
} else if *f == f64::INFINITY {
m.serialize_entry("v", "Infinity")?;
} else if *f == f64::NEG_INFINITY {
m.serialize_entry("v", "-Infinity")?;
} else {
m.serialize_entry("v", f)?;
}
}
Value::String(s) => write_tagged_str(&mut m, s)?,
Value::Uuid(u) => {
m.serialize_entry("t", "uuid")?;
m.serialize_entry("v", &uuid_hyphenated(*u))?;
}
Value::List(xs) => {
m.serialize_entry("t", "list")?;
m.serialize_entry("v", &TaggedListRef(xs))?;
}
Value::Map(map) => {
m.serialize_entry("t", "map")?;
m.serialize_entry("v", &TaggedMapRef(map))?;
}
Value::Node(_) | Value::Relationship(_) | Value::Path(_) => {
return Err(serde::ser::Error::custom(
"graph entity is not a persistence property",
));
}
Value::Bytes(_) => {
return Err(serde::ser::Error::custom(
"byte array is not a persistence property",
));
}
Value::Temporal(t) => {
m.serialize_entry("t", t.kind_name())?;
m.serialize_entry("v", &t.iso_string())?;
}
Value::Point(p) => {
m.serialize_entry("t", "point")?;
m.serialize_entry("v", &TaggedPointRef(p))?;
}
Value::Vector { coord, values } => {
m.serialize_entry("coord", coord.canonical_name())?;
m.serialize_entry("t", "vector")?;
m.serialize_entry("v", &TaggedListRef(values))?;
}
}
m.end()
}
}
struct TaggedListRef<'a>(&'a [Value]);
impl serde::Serialize for TaggedListRef<'_> {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeSeq;
let mut seq = s.serialize_seq(Some(self.0.len()))?;
for v in self.0 {
seq.serialize_element(&TaggedRef(v))?;
}
seq.end()
}
}
struct TaggedMapRef<'a>(&'a BTreeMap<String, Value>);
impl serde::Serialize for TaggedMapRef<'_> {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeMap;
let mut m = s.serialize_map(Some(self.0.len()))?;
for (k, v) in self.0 {
m.serialize_entry(k, &TaggedRef(v))?;
}
m.end()
}
}
struct TaggedPointRef<'a>(&'a PointValue);
impl serde::Serialize for TaggedPointRef<'_> {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeMap;
let p = self.0;
let mut m = s.serialize_map(Some(4))?;
m.serialize_entry("srid", &p.srid)?;
m.serialize_entry("x", &p.x)?;
m.serialize_entry("y", &p.y)?;
m.serialize_entry("z", &p.z)?;
m.end()
}
}
impl serde::Serialize for Value {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
if !self.depth_within(MAX_VALUE_DEPTH) {
return Err(serde::ser::Error::custom(value_depth_exceeded("value")));
}
TaggedRef(self).serialize(serializer)
}
}
impl<'de> serde::Deserialize<'de> for Value {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let json = serde_json::Value::deserialize(deserializer)?;
Value::from_json_tagged(&json).map_err(serde::de::Error::custom)
}
}
fn map_to_json_plain<'a>(
m: impl IntoIterator<Item = (&'a String, &'a Value)>,
depth: u32,
) -> serde_json::Value {
let mut o = serde_json::Map::new();
for (k, v) in m {
o.insert(k.clone(), v.to_json_plain_at(depth));
}
serde_json::Value::Object(o)
}
fn node_json(n: &Node, depth: u32) -> serde_json::Value {
let Some(next) = next_depth(depth) else {
return serde_json::Value::Null;
};
serde_json::json!({
"_type": "node",
"id": n.id,
"labels": n.labels,
"properties": map_to_json_plain(n.properties.iter(), next),
})
}
fn rel_json(r: &Relationship, depth: u32) -> serde_json::Value {
let Some(next) = next_depth(depth) else {
return serde_json::Value::Null;
};
serde_json::json!({
"_type": "relationship",
"id": r.id,
"start": r.start,
"end": r.end,
"type": r.rel_type,
"properties": map_to_json_plain(r.properties.iter(), next),
})
}