use super::envelope::Row;
use super::format::Formatter;
use crate::error::Result;
use std::io::Write;
pub const INITIAL_LINE_CAPACITY: usize = 4096;
pub struct Sink<'a, W: Write> {
pub writer: W,
pub formatter: Box<dyn Formatter>,
pub tail: &'a crate::output::Envelope,
}
pub struct Stream<W: Write> {
writer: W,
formatter: Box<dyn Formatter>,
line: String,
emitted: u64,
}
impl<W: Write> Stream<W> {
pub fn open(
mut writer: W,
mut formatter: Box<dyn Formatter>,
head: &crate::output::Envelope,
columns: &[String],
) -> Result<Self> {
formatter.begin_stream(&mut writer, head, columns)?;
Ok(Self {
writer,
formatter,
line: String::with_capacity(INITIAL_LINE_CAPACITY),
emitted: 0,
})
}
pub fn write(&mut self, row: &Row) -> Result<()> {
self.formatter
.write_row(&mut self.writer, row, &mut self.line)?;
self.emitted += 1;
Ok(())
}
#[must_use]
pub const fn emitted(&self) -> u64 {
self.emitted
}
#[must_use]
pub fn buffer_capacity(&self) -> usize {
self.line.capacity()
}
pub fn finish(
mut self,
tail: &crate::output::Envelope,
gaps: &[crate::output::envelope::Gap],
applied: Option<&crate::output::envelope::Applied>,
) -> Result<u64> {
self.formatter
.end_stream(&mut self.writer, tail, self.emitted, gaps, applied)?;
self.writer.flush().ok();
Ok(self.emitted)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::output::format::{ndjson::Ndjson, END_OF_STREAM_KEY, ROW_COUNT_KEY};
use indexmap::IndexMap;
use serde_json::json;
fn tail() -> crate::output::Envelope {
crate::output::Envelope::new("query run", json!({}))
}
fn row(index: u64) -> Row {
let mut row = IndexMap::new();
row.insert("id".to_owned(), json!(index));
row.insert("name".to_owned(), json!(format!("row-{index}")));
row
}
#[test]
fn a_whole_flow_ends_with_the_count_it_emitted() {
let mut out = Vec::new();
let mut stream = Stream::open(&mut out, Box::new(Ndjson), &tail(), &[]).expect("opens");
for index in 0..5 {
stream.write(&row(index)).expect("writes");
}
assert_eq!(stream.finish(&tail(), &[], None).expect("closes"), 5);
let text = String::from_utf8(out).expect("utf8");
let last = text.lines().next_back().expect("a last line");
let parsed: serde_json::Value = serde_json::from_str(last).expect("parses");
assert_eq!(parsed[END_OF_STREAM_KEY], true);
assert_eq!(parsed[ROW_COUNT_KEY], 5);
assert_eq!(text.lines().count(), 6, "five rows and the closing record");
}
#[test]
fn a_flow_cut_in_the_middle_carries_no_closing_record() {
struct FailsAfter {
remaining: usize,
written: Vec<u8>,
}
impl Write for FailsAfter {
fn write(&mut self, buffer: &[u8]) -> std::io::Result<usize> {
if self.remaining == 0 {
return Err(std::io::Error::new(
std::io::ErrorKind::ConnectionReset,
"the connection dropped",
));
}
self.remaining -= 1;
self.written.extend_from_slice(buffer);
Ok(buffer.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
let sink = FailsAfter {
remaining: 4,
written: Vec::new(),
};
let mut stream = Stream::open(sink, Box::new(Ndjson), &tail(), &[]).expect("opens");
stream.write(&row(0)).expect("first row goes through");
stream.write(&row(1)).expect("second row goes through");
let dropped = stream.write(&row(2)).expect_err("the connection dropped");
assert_eq!(dropped.code(), "output.write_failed");
drop(stream);
}
#[test]
fn what_reached_the_channel_before_a_drop_is_whole_but_unterminated() {
let mut out = Vec::new();
{
let mut stream = Stream::open(&mut out, Box::new(Ndjson), &tail(), &[]).expect("opens");
stream.write(&row(0)).expect("writes");
stream.write(&row(1)).expect("writes");
}
let text = String::from_utf8(out).expect("utf8");
assert_eq!(text.lines().count(), 2, "only the rows that made it");
assert!(
!text.contains(END_OF_STREAM_KEY),
"a cut set must never look whole: {text}"
);
for line in text.lines() {
let _: serde_json::Value = serde_json::from_str(line).expect("each line is whole");
}
}
#[test]
fn the_line_buffer_is_reused_and_not_rebuilt_per_row() {
let mut out = Vec::new();
let mut stream = Stream::open(&mut out, Box::new(Ndjson), &tail(), &[]).expect("opens");
let before = stream.buffer_capacity();
assert!(
before >= INITIAL_LINE_CAPACITY,
"room is reserved once, up front"
);
for index in 0..10_000 {
stream.write(&row(index)).expect("writes");
}
assert_eq!(
stream.buffer_capacity(),
before,
"a long flow must not grow the buffer row by row"
);
assert_eq!(stream.finish(&tail(), &[], None).expect("closes"), 10_000);
}
#[test]
fn an_empty_flow_still_declares_itself_complete() {
let mut out = Vec::new();
let stream = Stream::open(&mut out, Box::new(Ndjson), &tail(), &[]).expect("opens");
assert_eq!(stream.finish(&tail(), &[], None).expect("closes"), 0);
let text = String::from_utf8(out).expect("utf8");
assert!(text.contains(END_OF_STREAM_KEY));
}
}