use std::collections::BTreeMap;
use itertools::Itertools;
use miette::{miette, Result};
use serde_json::json;
use crate::data::json::JsonValue;
use crate::data::tuple::Tuple;
use crate::data::value::DataValue;
#[derive(serde_derive::Serialize, serde_derive::Deserialize, Debug, Clone, Default)]
pub struct NamedRows {
pub headers: Vec<String>,
pub rows: Vec<Tuple>,
pub next: Option<Box<NamedRows>>,
}
impl IntoIterator for NamedRows {
type Item = Tuple;
type IntoIter = std::vec::IntoIter<Self::Item>;
fn into_iter(self) -> Self::IntoIter {
self.rows.into_iter()
}
}
impl NamedRows {
pub fn new(headers: Vec<String>, rows: Vec<Tuple>) -> Self {
Self {
headers,
rows,
next: None,
}
}
pub fn has_more(&self) -> bool {
self.next.is_some()
}
pub fn flatten(self) -> Vec<Self> {
let mut collected = vec![];
let mut current = self;
loop {
let nxt = current.next.take();
collected.push(current);
if let Some(n) = nxt {
current = *n;
} else {
break;
}
}
collected
}
pub fn into_json(self) -> JsonValue {
let nxt = match self.next {
None => json!(null),
Some(more) => more.into_json(),
};
let rows = self
.rows
.into_iter()
.map(|row| row.into_iter().map(JsonValue::from).collect::<JsonValue>())
.collect::<JsonValue>();
json!({
"headers": self.headers,
"rows": rows,
"next": nxt,
})
}
pub fn from_json(value: &JsonValue) -> Result<Self> {
let headers = value
.get("headers")
.ok_or_else(|| miette!("NamedRows requires 'headers' field"))?;
let headers = headers
.as_array()
.ok_or_else(|| miette!("'headers' field must be an array"))?;
let headers = headers
.iter()
.map(|h| -> Result<String> {
let h = h
.as_str()
.ok_or_else(|| miette!("'headers' field must be an array of strings"))?;
Ok(h.to_string())
})
.try_collect()?;
let rows = value
.get("rows")
.ok_or_else(|| miette!("NamedRows requires 'rows' field"))?;
let rows = rows
.as_array()
.ok_or_else(|| miette!("'rows' field must be an array"))?;
let rows = rows
.iter()
.map(|row| -> Result<Vec<DataValue>> {
let row = row
.as_array()
.ok_or_else(|| miette!("'rows' field must be an array of arrays"))?;
Ok(row.iter().map(DataValue::from).collect_vec())
})
.try_collect()?;
Ok(Self {
headers,
rows,
next: None,
})
}
pub fn into_payload(self, relation: &str, op: &str) -> Payload {
let cols_str = self.headers.join(", ");
let query = format!("?[{cols_str}] <- $data :{op} {relation} {{ {cols_str} }}");
let data = DataValue::List(self.rows.into_iter().map(|r| DataValue::List(r)).collect());
(query, [("data".to_string(), data)].into())
}
}
pub type Payload = (String, BTreeMap<String, DataValue>);
#[derive(Eq, PartialEq, Debug)]
pub enum TransactionPayload {
Commit,
Abort,
Query(Payload),
}