use super::{emit, emit_line, to_compact, Formatter, ROW_COUNT_KEY};
use crate::error::Result;
use crate::output::envelope::{Applied, Envelope, Row};
use std::fmt::Write as _;
use std::io::Write;
#[derive(Debug, Default)]
pub struct Json {
wrote_row: bool,
}
impl Formatter for Json {
fn name(&self) -> &'static str {
"json"
}
fn write_envelope(&mut self, writer: &mut dyn Write, envelope: &Envelope) -> Result<()> {
emit_line(writer, &to_compact(envelope)?)
}
fn begin_stream(
&mut self,
writer: &mut dyn Write,
head: &Envelope,
columns: &[String],
) -> Result<()> {
self.wrote_row = false;
emit(writer, &opening(head, columns)?)
}
fn write_row(&mut self, writer: &mut dyn Write, row: &Row, line: &mut String) -> Result<()> {
line.clear();
if self.wrote_row {
line.push(',');
}
line.push_str(&to_compact(row)?);
self.wrote_row = true;
emit(writer, line)
}
fn end_stream(
&mut self,
writer: &mut dyn Write,
_tail: &Envelope,
emitted: u64,
gaps: &[crate::output::envelope::Gap],
applied: Option<&Applied>,
) -> Result<()> {
let counted = declared_row_count(emitted, applied);
let declared = super::gaps_as_json(gaps)?;
let reported = match applied {
Some(applied) => format!(r#","applied":{}"#, to_compact(applied)?),
None => String::new(),
};
emit_line(
writer,
&format!(r#"],"{ROW_COUNT_KEY}":{counted}}}{declared}{reported}}}"#),
)
}
}
fn opening(head: &Envelope, columns: &[String]) -> Result<String> {
let document = super::to_document(head)?;
let mut text = String::from("{");
for (name, value) in &document {
if name == PAYLOAD {
break;
}
if text.len() > 1 {
text.push(',');
}
text.push_str(&to_compact(name)?);
text.push(':');
text.push_str(&to_compact(value)?);
}
if text.len() > 1 {
text.push(',');
}
write!(
text,
r#""{PAYLOAD}":{{"columns":{},"rows":["#,
to_compact(&columns)?
)
.map_err(|error| {
crate::error::Failure::new(
crate::error::Category::Server,
"output.not_serialisable",
"the opening of the answer could not be written",
)
.with_cause(error.to_string())
})?;
Ok(text)
}
const PAYLOAD: &str = "data";
fn declared_row_count(emitted: u64, applied: Option<&Applied>) -> u64 {
applied
.and_then(|applied| applied.input_count)
.and_then(|count| u64::try_from(count).ok())
.unwrap_or(emitted)
}
#[cfg(test)]
mod tests {
use super::super::tests::{
sample_row, stream_through, stream_through_from, tail_from_a_destination,
};
use super::*;
use serde_json::json;
#[test]
fn the_document_names_the_command_and_the_destination() {
let rows = vec![sample_row("alpha", 1)];
let text = stream_through_from(&mut Json::default(), &rows, &tail_from_a_destination());
let parsed: serde_json::Value =
serde_json::from_str(text.trim_end()).expect("one document");
assert_eq!(parsed["command"], "query run");
assert_eq!(parsed["target_resolved"]["host"], "192.0.2.10");
assert_eq!(parsed["data"][ROW_COUNT_KEY], 1);
}
#[test]
fn the_document_opens_with_the_envelope_and_not_with_the_rows() {
let rows = vec![sample_row("alpha", 1)];
let text = stream_through_from(&mut Json::default(), &rows, &tail_from_a_destination());
assert!(
text.starts_with(r#"{"command":"query run","schema_version":1,"target_resolved":{"#),
"the document must open as its gathered form opens: {text}"
);
let target_at = text.find(r#""target_resolved""#).expect("a destination");
let rows_at = text.find(r#""rows""#).expect("a payload");
assert!(
target_at < rows_at,
"the envelope precedes the rows: {text}"
);
}
#[test]
fn an_answer_is_one_document_on_one_line() {
let envelope = Envelope::new("meta version", json!({"version": "0.1.0"}));
let mut out = Vec::new();
Json::default()
.write_envelope(&mut out, &envelope)
.expect("writes");
let text = String::from_utf8(out).expect("utf8");
assert_eq!(text.matches('\n').count(), 1);
assert!(text.ends_with('\n'));
let parsed: serde_json::Value =
serde_json::from_str(text.trim_end()).expect("one document");
assert_eq!(parsed["command"], "meta version");
}
#[test]
fn a_whole_flow_is_one_document_that_declares_its_count() {
let rows = vec![sample_row("alpha", 1), sample_row("beta", 2)];
let text = stream_through(&mut Json::default(), &rows);
let parsed: serde_json::Value =
serde_json::from_str(text.trim_end()).expect("one document");
assert_eq!(parsed["data"]["rows"].as_array().expect("array").len(), 2);
assert_eq!(parsed["data"][ROW_COUNT_KEY], 2);
assert!(
!text.contains(super::super::END_OF_STREAM_KEY),
"a document says it is whole by closing: {text}"
);
}
#[test]
fn a_flow_cut_part_way_through_leaves_a_document_that_never_closes() {
let mut formatter = Json::default();
let mut out = Vec::new();
formatter
.begin_stream(&mut out, &tail_from_a_destination(), &["name".to_owned()])
.expect("opens");
let mut line = String::new();
formatter
.write_row(&mut out, &sample_row("alpha", 1), &mut line)
.expect("writes");
let text = String::from_utf8(out).expect("utf8");
assert!(
serde_json::from_str::<serde_json::Value>(&text).is_err(),
"a cut flow must not parse as a whole answer: {text}"
);
}
#[test]
fn an_empty_flow_still_closes_with_a_count_of_zero() {
let text = stream_through(&mut Json::default(), &[]);
let parsed: serde_json::Value =
serde_json::from_str(text.trim_end()).expect("one document");
assert_eq!(parsed["data"][ROW_COUNT_KEY], 0);
assert_eq!(parsed["data"]["rows"].as_array().expect("array").len(), 0);
}
#[test]
fn what_the_pipeline_did_is_reported_exactly_as_the_gathered_form_reports_it() {
let mut formatter = Json::default();
let mut out = Vec::new();
let tail = tail_from_a_destination();
formatter
.begin_stream(&mut out, &tail, &["name".to_owned()])
.expect("opens");
let reported = Applied {
input_count: Some(9),
output_count: Some(0),
dropped: Some(9),
..Applied::default()
};
formatter
.end_stream(&mut out, &tail, 0, &[], Some(&reported))
.expect("closes");
let text = String::from_utf8(out).expect("utf8");
let parsed: serde_json::Value =
serde_json::from_str(text.trim_end()).expect("one document");
assert_eq!(parsed["applied"]["input_count"], 9);
assert_eq!(parsed["applied"]["dropped"], 9);
assert_eq!(
parsed["data"][ROW_COUNT_KEY], 9,
"the payload declares the rows the read returned, as the gathered form does: {text}"
);
}
#[test]
fn column_order_survives_the_round_trip() {
let rows = vec![sample_row("alpha", 1)];
let text = stream_through(&mut Json::default(), &rows);
let name_at = text.find("\"name\"").expect("name present");
let size_at = text.find("\"size\"").expect("size present");
assert!(name_at < size_at, "declared column order must survive");
}
}